15 throw std::runtime_error(
"muggH called with a class whose parent is not NPbase");
27 throw std::runtime_error(
"muVBF called with a class whose parent is not NPbase");
40 throw std::runtime_error(
"muVBFgamma called with a class whose parent is not NPbase");
53 throw std::runtime_error(
"mueeWBF called with a class whose parent is not NPbase");
63:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
66 throw std::runtime_error(
"mueeWBFPol called with a class whose parent is not NPbase");
78 throw std::runtime_error(
"mueeHvv called with a class whose parent is not NPbase");
87:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
90 throw std::runtime_error(
"mueeHvvPol called with a class whose parent is not NPbase");
102 throw std::runtime_error(
"mueeZBF called with a class whose parent is not NPbase");
112:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
115 throw std::runtime_error(
"mueeZBFPol called with a class whose parent is not NPbase");
127 throw std::runtime_error(
"muepWBF called with a class whose parent is not NPbase");
140 throw std::runtime_error(
"muWH called with a class whose parent is not NPbase");
152 throw std::runtime_error(
"muWHpT250 called with a class whose parent is not NPbase");
164 throw std::runtime_error(
"muepZBF called with a class whose parent is not NPbase");
177 throw std::runtime_error(
"muZH called with a class whose parent is not NPbase");
189 throw std::runtime_error(
"muZHpT250 called with a class whose parent is not NPbase");
199:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
202 throw std::runtime_error(
"mueeZHGen called with a class whose parent is not NPbase");
212:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
215 throw std::runtime_error(
"mueeZH called with a class whose parent is not NPbase");
227 throw std::runtime_error(
"mueeZllH called with a class whose parent is not NPbase");
236:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
239 throw std::runtime_error(
"mueeZllHPol called with a class whose parent is not NPbase");
251 throw std::runtime_error(
"mueeZqqH called with a class whose parent is not NPbase");
260:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
263 throw std::runtime_error(
"mueeZqqHPol called with a class whose parent is not NPbase");
273:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
276 throw std::runtime_error(
"aPsk called with a class whose parent is not NPbase");
286:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
289 throw std::runtime_error(
"bPsk called with a class whose parent is not NPbase");
302 throw std::runtime_error(
"muVH called with a class whose parent is not NPbase");
314 throw std::runtime_error(
"muVHpT250 called with a class whose parent is not NPbase");
326 throw std::runtime_error(
"muVBFpVH called with a class whose parent is not NPbase");
338 throw std::runtime_error(
"muttH called with a class whose parent is not NPbase");
350 throw std::runtime_error(
"mutHq called with a class whose parent is not NPbase");
362 throw std::runtime_error(
"muggHpttH called with a class whose parent is not NPbase");
374 throw std::runtime_error(
"mueettH called with a class whose parent is not NPbase");
384:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
387 throw std::runtime_error(
"mueettHPol called with a class whose parent is not NPbase");
399 throw std::runtime_error(
"mummH called with a class whose parent is not NPbase");
411 throw std::runtime_error(
"mummHNWA called with a class whose parent is not NPbase");
427 throw std::runtime_error(
"GammaHtoggRatio called with a class whose parent is not NPbase");
439 throw std::runtime_error(
"GammaHtoWWRatio called with a class whose parent is not NPbase");
451 throw std::runtime_error(
"GammaHtoZZRatio called with a class whose parent is not NPbase");
462 throw std::runtime_error(
"GammaHtoZgaRatio called with a class whose parent is not NPbase");
473 throw std::runtime_error(
"GammaHtogagaRatio called with a class whose parent is not NPbase");
484 throw std::runtime_error(
"GammaHtomumuRatio called with a class whose parent is not NPbase");
495 throw std::runtime_error(
"GammaHtotautauRatio called with a class whose parent is not NPbase");
506 throw std::runtime_error(
"GammaHtossRatio called with a class whose parent is not NPbase");
517 throw std::runtime_error(
"GammaHtoccRatio called with a class whose parent is not NPbase");
528 throw std::runtime_error(
"GammaHtobbRatio called with a class whose parent is not NPbase");
540 throw std::runtime_error(
"GammaHRatio called with a class whose parent is not NPbase");
555 throw std::runtime_error(
"BrHtoinvRatio called with a class whose parent is not NPbase");
567 throw std::runtime_error(
"BrHinvisible called with a class whose parent is not NPbase");
579 throw std::runtime_error(
"BrHinvisibleNP called with a class whose parent is not NPbase");
591 throw std::runtime_error(
"BrHexotic called with a class whose parent is not NPbase");
603 throw std::runtime_error(
"BrHtovisRatio called with a class whose parent is not NPbase");
615 throw std::runtime_error(
"BrHtoggRatio called with a class whose parent is not NPbase");
627 throw std::runtime_error(
"BrHtoWWRatio called with a class whose parent is not NPbase");
639 throw std::runtime_error(
"BrHtoZZRatio called with a class whose parent is not NPbase");
651 throw std::runtime_error(
"BrHtoVVRatio called with a class whose parent is not NPbase");
662 throw std::runtime_error(
"BrHtoZgaRatio called with a class whose parent is not NPbase");
673 throw std::runtime_error(
"BrHtoZgallRatio called with a class whose parent is not NPbase");
684 throw std::runtime_error(
"BrHtoZgaeeRatio called with a class whose parent is not NPbase");
695 throw std::runtime_error(
"BrHtoZgamumuRatio called with a class whose parent is not NPbase");
706 throw std::runtime_error(
"BrHtogagaRatio called with a class whose parent is not NPbase");
717 throw std::runtime_error(
"BrHtomumuRatio called with a class whose parent is not NPbase");
728 throw std::runtime_error(
"BrHtotautauRatio called with a class whose parent is not NPbase");
739 throw std::runtime_error(
"BrHtoccRatio called with a class whose parent is not NPbase");
750 throw std::runtime_error(
"BrHtobbRatio called with a class whose parent is not NPbase");
767 throw std::runtime_error(
"BrHto2l2vRatio called with a class whose parent is not NPbase");
780 throw std::runtime_error(
"BrHtoevmuvRatio called with a class whose parent is not NPbase");
793 throw std::runtime_error(
"BrHto2e2vRatio called with a class whose parent is not NPbase");
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
812 throw std::runtime_error(
"BrHto2mu2vRatio called with a class whose parent is not NPbase");
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
831 throw std::runtime_error(
"BrHto4lRatio called with a class whose parent is not NPbase");
844 throw std::runtime_error(
"BrHto4eRatio called with a class whose parent is not NPbase");
857 throw std::runtime_error(
"BrHto4muRatio called with a class whose parent is not NPbase");
870 throw std::runtime_error(
"BrHto2e2muRatio called with a class whose parent is not NPbase");
884 throw std::runtime_error(
"BrHtolljjRatio called with a class whose parent is not NPbase");
897 throw std::runtime_error(
"BrHtolvjjRatio called with a class whose parent is not NPbase");
910 throw std::runtime_error(
"BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
923 throw std::runtime_error(
"BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
938 throw std::runtime_error(
"BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
943 if ((this->
getModel()).isModelLinearized()) {
953 throw std::runtime_error(
"BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
958 if ((this->
getModel()).isModelLinearized()) {
968 throw std::runtime_error(
"BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
973 if ((this->
getModel()).isModelLinearized()) {
983 throw std::runtime_error(
"BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
988 if ((this->
getModel()).isModelLinearized()) {
998 throw std::runtime_error(
"BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
1003 if ((this->
getModel()).isModelLinearized()) {
1013 throw std::runtime_error(
"BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1018 if ((this->
getModel()).isModelLinearized()) {
1028 throw std::runtime_error(
"BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1033 if ((this->
getModel()).isModelLinearized()) {
1044 throw std::runtime_error(
"BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1049 if ((this->
getModel()).isModelLinearized()) {
1060 throw std::runtime_error(
"BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1065 if ((this->
getModel()).isModelLinearized()) {
1076 throw std::runtime_error(
"BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1081 if ((this->
getModel()).isModelLinearized()) {
1091 throw std::runtime_error(
"BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1096 if ((this->
getModel()).isModelLinearized()) {
1106 throw std::runtime_error(
"BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1111 if ((this->
getModel()).isModelLinearized()) {
1121 throw std::runtime_error(
"BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1126 if ((this->
getModel()).isModelLinearized()) {
1136 throw std::runtime_error(
"BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1141 if ((this->
getModel()).isModelLinearized()) {
1151 throw std::runtime_error(
"BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1156 if ((this->
getModel()).isModelLinearized()) {
1166 throw std::runtime_error(
"BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1171 if ((this->
getModel()).isModelLinearized()) {
1182 throw std::runtime_error(
"BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1187 if ((this->
getModel()).isModelLinearized()) {
1198 throw std::runtime_error(
"BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1203 if ((this->
getModel()).isModelLinearized()) {
1214 throw std::runtime_error(
"BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1219 if ((this->
getModel()).isModelLinearized()) {
1230 throw std::runtime_error(
"BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1235 if ((this->
getModel()).isModelLinearized()) {
1246 throw std::runtime_error(
"BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1251 if ((this->
getModel()).isModelLinearized()) {
1267 throw std::runtime_error(
"muggHgaga called with a class whose parent is not NPbase");
1272 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1295 throw std::runtime_error(
"muggHgagaInt called with a class whose parent is not NPbase");
1307 throw std::runtime_error(
"muVBFHgaga called with a class whose parent is not NPbase");
1312 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1330 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1342 throw std::runtime_error(
"muZHgaga called with a class whose parent is not NPbase");
1347 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1365 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1378 throw std::runtime_error(
"muWHgaga called with a class whose parent is not NPbase");
1383 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1401 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1414 throw std::runtime_error(
"muVHgaga called with a class whose parent is not NPbase");
1419 if ((this->
getModel()).isModelLinearized()) {
1430 throw std::runtime_error(
"muttHgaga called with a class whose parent is not NPbase");
1435 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1453 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1466 throw std::runtime_error(
"mutHgaga called with a class whose parent is not NPbase");
1471 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1488 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1496 if(NPmutHgaga==1.0){
1508 throw std::runtime_error(
"muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1513 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1530 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1543 return NPmuggHpbbH_Hgaga;
1552 throw std::runtime_error(
"muttHptH_Hgaga called with a class whose parent is not NPbase");
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1567 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1584 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1592 if(NPmuttHptH_Hgaga==1.0){
1595 return NPmuttHptH_Hgaga;
1604 throw std::runtime_error(
"muggHZga called with a class whose parent is not NPbase");
1609 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1627 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1640 throw std::runtime_error(
"muggHZgamumu called with a class whose parent is not NPbase");
1645 if ((this->
getModel()).isModelLinearized()) {
1656 throw std::runtime_error(
"muVBFHZga called with a class whose parent is not NPbase");
1661 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1679 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1692 throw std::runtime_error(
"muZHZga called with a class whose parent is not NPbase");
1697 if ((this->
getModel()).isModelLinearized()) {
1708 throw std::runtime_error(
"muWHZga called with a class whose parent is not NPbase");
1713 if ((this->
getModel()).isModelLinearized()) {
1724 throw std::runtime_error(
"muVHZga called with a class whose parent is not NPbase");
1729 if ((this->
getModel()).isModelLinearized()) {
1740 throw std::runtime_error(
"muttHZga called with a class whose parent is not NPbase");
1745 if ((this->
getModel()).isModelLinearized()) {
1760 throw std::runtime_error(
"muggHpttHptHpbbH_HZga called with a class whose parent is not NPbase");
1774 double xsSM_ggHbbH = 44.745;
1775 double xsSM_ttH = 0.4998;
1776 double xsSM_tH = 0.084769;
1784 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1794 double Br1 = dGammaR1-dGammaRTot1;
1795 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1799 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1801 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1812 if(NPmuggHpttHptHpbbH_HZga==1.0){
1815 return NPmuggHpttHptHpbbH_HZga;
1825 throw std::runtime_error(
"muVBFpVH_HZga called with a class whose parent is not NPbase");
1836 double xsSM_VBF = 3.49948;
1837 double xsSM_WH = 1.21539;
1838 double xsSM_ZH = 0.795910;
1842 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1852 double Br1 = dGammaR1-dGammaRTot1;
1853 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1857 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1859 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1868 if(NPmuVBFpVH_HZga==1.0){
1871 return NPmuVBFpVH_HZga;
1885 throw std::runtime_error(
"muggHZZ called with a class whose parent is not NPbase");
1890 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1901 double Br1 = dGammaR1-dGammaRTot1;
1902 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1906 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1908 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1921 throw std::runtime_error(
"muVBFHZZ called with a class whose parent is not NPbase");
1926 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1937 double Br1 = dGammaR1-dGammaRTot1;
1938 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1942 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1944 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1957 throw std::runtime_error(
"muZHZZ called with a class whose parent is not NPbase");
1962 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1973 double Br1 = dGammaR1-dGammaRTot1;
1974 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1978 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1980 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1993 throw std::runtime_error(
"muWHZZ called with a class whose parent is not NPbase");
1998 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2009 double Br1 = dGammaR1-dGammaRTot1;
2010 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2014 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2016 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2029 throw std::runtime_error(
"muVHZZ called with a class whose parent is not NPbase");
2039 double xsSM_WH = 1.21539;
2040 double xsSM_ZH = 0.795910;
2043 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2054 double Br1 = dGammaR1-dGammaRTot1;
2055 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2059 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2061 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2082 throw std::runtime_error(
"muttHZZ called with a class whose parent is not NPbase");
2087 if ((this->
getModel()).isModelLinearized()) {
2098 throw std::runtime_error(
"muttHptH_HZZ called with a class whose parent is not NPbase");
2108 double xsSM_ttH = 0.499873;
2109 double xsSM_tH = 0.0821;
2112 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2123 double Br1 = dGammaR1-dGammaRTot1;
2124 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2128 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2130 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2139 if(NPmuttHptH_HZZ==1.0){
2142 return NPmuttHptH_HZZ;
2151 throw std::runtime_error(
"muttHptH_Hmumu called with a class whose parent is not NPbase");
2161 double xsSM_ttH = 0.499873;
2162 double xsSM_tH = 0.0821;
2165 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2176 double Br1 = dGammaR1-dGammaRTot1;
2177 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2181 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2183 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2192 if(NPmuttHptH_Hmumu==1.0){
2195 return NPmuttHptH_Hmumu;
2204 throw std::runtime_error(
"muggHpbbH_HZZ called with a class whose parent is not NPbase");
2209 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2220 double Br1 = dGammaR1-dGammaRTot1;
2221 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2225 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2227 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2237 if (NPmuggHpbbH_HZZ == 1.0){
2240 return NPmuggHpbbH_HZZ;
2249 throw std::runtime_error(
"muggHZZ4l called with a class whose parent is not NPbase");
2254 if ((this->
getModel()).isModelLinearized()) {
2265 throw std::runtime_error(
"muggHZZ4mu called with a class whose parent is not NPbase");
2270 if ((this->
getModel()).isModelLinearized()) {
2281 throw std::runtime_error(
"muVBFHZZ4l called with a class whose parent is not NPbase");
2286 if ((this->
getModel()).isModelLinearized()) {
2297 throw std::runtime_error(
"muZHZZ4l called with a class whose parent is not NPbase");
2302 if ((this->
getModel()).isModelLinearized()) {
2313 throw std::runtime_error(
"muWHZZ4l called with a class whose parent is not NPbase");
2318 if ((this->
getModel()).isModelLinearized()) {
2329 throw std::runtime_error(
"muVHZZ4l called with a class whose parent is not NPbase");
2334 if ((this->
getModel()).isModelLinearized()) {
2345 throw std::runtime_error(
"muttHZZ4l called with a class whose parent is not NPbase");
2350 if ((this->
getModel()).isModelLinearized()) {
2361 throw std::runtime_error(
"muggHWW called with a class whose parent is not NPbase");
2366 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2377 double Br1 = dGammaR1-dGammaRTot1;
2378 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2382 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2384 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2397 throw std::runtime_error(
"muVBFHWW called with a class whose parent is not NPbase");
2402 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2413 double Br1 = dGammaR1-dGammaRTot1;
2414 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2418 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2420 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2433 throw std::runtime_error(
"muZHWW called with a class whose parent is not NPbase");
2438 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2449 double Br1 = dGammaR1-dGammaRTot1;
2450 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2454 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2456 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2469 throw std::runtime_error(
"muWHWW called with a class whose parent is not NPbase");
2474 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2485 double Br1 = dGammaR1-dGammaRTot1;
2486 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2490 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2492 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2505 throw std::runtime_error(
"muVHWW called with a class whose parent is not NPbase");
2510 if ((this->
getModel()).isModelLinearized()) {
2521 throw std::runtime_error(
"muttHWW called with a class whose parent is not NPbase");
2526 if ((this->
getModel()).isModelLinearized()) {
2537 throw std::runtime_error(
"muttHptH_HWW called with a class whose parent is not NPbase");
2548 double xsSM_ttH = 0.499873;
2549 double xsSM_tH = 0.0821;
2552 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2562 double Br1 = dGammaR1-dGammaRTot1;
2563 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2567 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2569 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2578 if(NPmuttHptH_HWW==1.0){
2581 return NPmuttHptH_HWW;
2590 throw std::runtime_error(
"muggHpbbH_HWW called with a class whose parent is not NPbase");
2595 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2606 double Br1 = dGammaR1-dGammaRTot1;
2607 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2611 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2613 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2624 if (NPmuggHpbbH_HWW == 1.0){
2627 return NPmuggHpbbH_HWW;
2636 throw std::runtime_error(
"muggHWW2l2v called with a class whose parent is not NPbase");
2641 if ((this->
getModel()).isModelLinearized()) {
2652 throw std::runtime_error(
"muVBFHWW2l2v called with a class whose parent is not NPbase");
2657 if ((this->
getModel()).isModelLinearized()) {
2668 throw std::runtime_error(
"muZHWW2l2v called with a class whose parent is not NPbase");
2673 if ((this->
getModel()).isModelLinearized()) {
2684 throw std::runtime_error(
"muWHWW2l2v called with a class whose parent is not NPbase");
2689 if ((this->
getModel()).isModelLinearized()) {
2700 throw std::runtime_error(
"muVHWW2l2v called with a class whose parent is not NPbase");
2705 if ((this->
getModel()).isModelLinearized()) {
2716 throw std::runtime_error(
"muttHWW2l2v called with a class whose parent is not NPbase");
2721 if ((this->
getModel()).isModelLinearized()) {
2732 throw std::runtime_error(
"muttHVV called with a class whose parent is not NPbase");
2737 if ((this->
getModel()).isModelLinearized()) {
2748 throw std::runtime_error(
"muggHmumu called with a class whose parent is not NPbase");
2753 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2764 double Br1 = dGammaR1-dGammaRTot1;
2765 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2769 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2771 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2784 throw std::runtime_error(
"muVBFHmumu called with a class whose parent is not NPbase");
2789 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2800 double Br1 = dGammaR1-dGammaRTot1;
2801 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2805 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2807 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2820 throw std::runtime_error(
"muZHmumu called with a class whose parent is not NPbase");
2825 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2835 double Br1 = dGammaR1-dGammaRTot1;
2836 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2840 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2842 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2855 throw std::runtime_error(
"muWHmumu called with a class whose parent is not NPbase");
2860 if ((this->
getModel()).isModelLinearized()) {
2871 throw std::runtime_error(
"muVHmumu called with a class whose parent is not NPbase");
2882 double xsSM_WH = 1.21539;
2883 double xsSM_ZH = 0.795910;
2886 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2897 double Br1 = dGammaR1-dGammaRTot1;
2898 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2902 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2904 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2913 if(NPmuVHmumu==1.0){
2926 throw std::runtime_error(
"muttHmumu called with a class whose parent is not NPbase");
2931 if ((this->
getModel()).isModelLinearized()) {
2942 throw std::runtime_error(
"muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2956 double xsSM_ggHbbH = 44.745;
2957 double xsSM_ttH = 0.4998;
2958 double xsSM_tH = 0.084769;
2966 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2976 double Br1 = dGammaR1-dGammaRTot1;
2977 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2981 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2983 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2994 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2997 return NPmuggHpttHptHpbbH_Hmumu;
3006 throw std::runtime_error(
"muVBFpVH_Hmumu called with a class whose parent is not NPbase");
3017 double xsSM_VBF = 3.49948;
3018 double xsSM_WH = 1.21539;
3019 double xsSM_ZH = 0.795910;
3023 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3033 double Br1 = dGammaR1-dGammaRTot1;
3034 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3038 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3040 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3049 if(NPmuVBFpVH_Hmumu==1.0){
3052 return NPmuVBFpVH_Hmumu;
3061 throw std::runtime_error(
"muggHtautau called with a class whose parent is not NPbase");
3066 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3077 double Br1 = dGammaR1-dGammaRTot1;
3078 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3082 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3084 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3097 throw std::runtime_error(
"muVBFHtautau called with a class whose parent is not NPbase");
3102 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3113 double Br1 = dGammaR1-dGammaRTot1;
3114 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3118 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3120 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3135 throw std::runtime_error(
"muVBFpVHtautau called with a class whose parent is not NPbase");
3140 if ((this->
getModel()).isModelLinearized()) {
3152 throw std::runtime_error(
"muZHtautau called with a class whose parent is not NPbase");
3157 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3169 double Br1 = dGammaR1-dGammaRTot1;
3170 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3174 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3176 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3189 throw std::runtime_error(
"muWHtautau called with a class whose parent is not NPbase");
3194 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3205 double Br1 = dGammaR1-dGammaRTot1;
3206 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3222 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3235 throw std::runtime_error(
"muVHtautau called with a class whose parent is not NPbase");
3245 double xsSM_WH = 1.21539;
3246 double xsSM_ZH = 0.795910;
3249 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3260 double Br1 = dGammaR1-dGammaRTot1;
3261 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3265 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3267 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3277 if(NPmuVHtautau==1.0){
3280 return NPmuVHtautau;
3289 throw std::runtime_error(
"muttHtautau called with a class whose parent is not NPbase");
3294 if ((this->
getModel()).isModelLinearized()) {
3305 throw std::runtime_error(
"muttHptH_Htautau called with a class whose parent is not NPbase");
3315 double xsSM_ttH = 0.499873;
3316 double xsSM_tH = 0.0821;
3319 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3329 double Br1 = dGammaR1-dGammaRTot1;
3330 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3334 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3336 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3345 if(NPmuttHptH_Htautau==1.0){
3348 return NPmuttHptH_Htautau;
3358 throw std::runtime_error(
"muggHpbbH_Htautau called with a class whose parent is not NPbase");
3363 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3374 double Br1 = dGammaR1-dGammaRTot1;
3375 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3379 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3381 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3392 if (NPmuggHpbbH_Htautau == 1.0){
3395 return NPmuggHpbbH_Htautau;
3404 throw std::runtime_error(
"muggHbb called with a class whose parent is not NPbase");
3409 if ((this->
getModel()).isModelLinearized()) {
3420 double Br1 = dGammaR1-dGammaRTot1;
3421 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3425 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3427 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3440 throw std::runtime_error(
"muVBFHbb called with a class whose parent is not NPbase");
3445 if ((this->
getModel()).isModelLinearized()) {
3456 throw std::runtime_error(
"muZHbb called with a class whose parent is not NPbase");
3461 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3472 double Br1 = dGammaR1-dGammaRTot1;
3473 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3477 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3479 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3492 throw std::runtime_error(
"muWHbb called with a class whose parent is not NPbase");
3497 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3508 double Br1 = dGammaR1-dGammaRTot1;
3509 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3513 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3515 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3528 throw std::runtime_error(
"muVHbb called with a class whose parent is not NPbase");
3533 if ((this->
getModel()).isModelLinearized()) {
3544 throw std::runtime_error(
"muttHbb called with a class whose parent is not NPbase");
3549 if ((this->
getModel()).isModelLinearized()) {
3560 throw std::runtime_error(
"muttHptH_Hbb called with a class whose parent is not NPbase");
3570 double xsSM_ttH = 0.499873;
3571 double xsSM_tH = 0.0821;
3574 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3584 double Br1 = dGammaR1-dGammaRTot1;
3585 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3589 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3591 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3601 if(NPmuttHptH_Hbb==1.0){
3604 return NPmuttHptH_Hbb;
3613 throw std::runtime_error(
"muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3627 double xsSM_ggHbbH = 44.745;
3628 double xsSM_VBF = 3.49948;
3632 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3642 double Br1 = dGammaR1-dGammaRTot1;
3643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3649 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3661 if(NPmuggHpVBFpbbH_Hbb==1.0){
3664 return NPmuggHpVBFpbbH_Hbb;
3675 throw std::runtime_error(
"muVHbb called with a class whose parent is not NPbase");
3680 if ((this->
getModel()).isModelLinearized()) {
3692 throw std::runtime_error(
"muVBFBRinv called with a class whose parent is not NPbase");
3706 throw std::runtime_error(
"muVBFHinv called with a class whose parent is not NPbase");
3712 if ((this->
getModel()).isModelLinearized()) {
3725 throw std::runtime_error(
"muVHBRinv called with a class whose parent is not NPbase");
3739 throw std::runtime_error(
"muVHinv called with a class whose parent is not NPbase");
3745 if ((this->
getModel()).isModelLinearized()) {
3758 throw std::runtime_error(
"muppHmumu called with a class whose parent is not NPbase");
3770 throw std::runtime_error(
"muppHZga called with a class whose parent is not NPbase");
3782 throw std::runtime_error(
"muggH called with a class whose parent is not NPbase");
3787 if ((this->
getModel()).isModelLinearized()) {
3798 throw std::runtime_error(
"muttHZbbboost called with a class whose parent is not NPbase");
3810 throw std::runtime_error(
"muttHgagaZeeboost called with a class whose parent is not NPbase");
3823 throw std::runtime_error(
"ggHgaga called with a class whose parent is not NPbase");
3827 double SM_prediction = 0.0439;
3828 if ((this->
getModel()).isModelLinearized()) {
3840 throw std::runtime_error(
"ggHZZ called with a class whose parent is not NPbase");
3844 double SM_prediction = 0.5197;
3845 if ((this->
getModel()).isModelLinearized()) {
3857 throw std::runtime_error(
"ggHWW called with a class whose parent is not NPbase");
3861 double SM_prediction = 4.1603;
3862 if ((this->
getModel()).isModelLinearized()) {
3874 throw std::runtime_error(
"ggHtautau called with a class whose parent is not NPbase");
3878 double SM_prediction = 1.2215;
3879 if ((this->
getModel()).isModelLinearized()) {
3891 throw std::runtime_error(
"VBFHgaga called with a class whose parent is not NPbase");
3895 double SM_prediction = 0.0037;
3896 if ((this->
getModel()).isModelLinearized()) {
3908 throw std::runtime_error(
"VBFHZZ called with a class whose parent is not NPbase");
3912 double SM_prediction = 0.0530;
3913 if ((this->
getModel()).isModelLinearized()) {
3925 throw std::runtime_error(
"VBFHWW called with a class whose parent is not NPbase");
3929 double SM_prediction = 0.3494;
3930 if ((this->
getModel()).isModelLinearized()) {
3942 throw std::runtime_error(
"VBFHtautau called with a class whose parent is not NPbase");
3946 double SM_prediction = 0.1011;
3947 if ((this->
getModel()).isModelLinearized()) {
3959 throw std::runtime_error(
"WHgaga called with a class whose parent is not NPbase");
3963 double SM_prediction = 0.0017;
3964 if ((this->
getModel()).isModelLinearized()) {
3976 throw std::runtime_error(
"WHWW called with a class whose parent is not NPbase");
3980 double SM_prediction = 0.1614;
3981 if ((this->
getModel()).isModelLinearized()) {
3993 throw std::runtime_error(
"WWHtautau called with a class whose parent is not NPbase");
3997 double SM_prediction = 0.0462;
3998 if ((this->
getModel()).isModelLinearized()) {
4010 throw std::runtime_error(
"WHbb called with a class whose parent is not NPbase");
4014 double SM_prediction = 0.4090;
4015 if ((this->
getModel()).isModelLinearized()) {
4027 throw std::runtime_error(
"ZHgaga called with a class whose parent is not NPbase");
4031 double SM_prediction = 0.0011;
4032 if ((this->
getModel()).isModelLinearized()) {
4044 throw std::runtime_error(
"ZHWW called with a class whose parent is not NPbase");
4048 double SM_prediction = 0.0996;
4049 if ((this->
getModel()).isModelLinearized()) {
4061 throw std::runtime_error(
"ZHtautau called with a class whose parent is not NPbase");
4065 double SM_prediction = 0.0304;
4066 if ((this->
getModel()).isModelLinearized()) {
4078 throw std::runtime_error(
"ZHbb called with a class whose parent is not NPbase");
4082 double SM_prediction = 0.2410;
4083 if ((this->
getModel()).isModelLinearized()) {
4095 throw std::runtime_error(
"ttHgaga called with a class whose parent is not NPbase");
4099 double SM_prediction = 0.0004;
4100 if ((this->
getModel()).isModelLinearized()) {
4112 throw std::runtime_error(
"ttHWW called with a class whose parent is not NPbase");
4116 double SM_prediction = 0.0281;
4117 if ((this->
getModel()).isModelLinearized()) {
4129 throw std::runtime_error(
"ttHtautau called with a class whose parent is not NPbase");
4133 double SM_prediction = 0.0106;
4134 if ((this->
getModel()).isModelLinearized()) {
4146 throw std::runtime_error(
"ttHbb called with a class whose parent is not NPbase");
4150 double SM_prediction = 0.0751;
4151 if ((this->
getModel()).isModelLinearized()) {
4163 throw std::runtime_error(
"UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4174 throw std::runtime_error(
"UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4185 throw std::runtime_error(
"UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4196 throw std::runtime_error(
"UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4207 throw std::runtime_error(
"cg_plus_ct called with a class whose parent is not NPbase");
4218 throw std::runtime_error(
"cga_plus_ct called with a class whose parent is not NPbase");
4229 throw std::runtime_error(
"cg_minus_cga called with a class whose parent is not NPbase");
4240 throw std::runtime_error(
"cV_plus_cb called with a class whose parent is not NPbase");
4253 throw std::runtime_error(
"cV_plus_ctau called with a class whose parent is not NPbase");
4264 throw std::runtime_error(
"cb_minus_cc called with a class whose parent is not NPbase");
4275 throw std::runtime_error(
"cb_minus_ctau called with a class whose parent is not NPbase");
4286 throw std::runtime_error(
"cc_minus_ctau called with a class whose parent is not NPbase");
4299:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4302 throw std::runtime_error(
"mueeZHbb called with a class whose parent is not NPbase");
4307 if ((this->
getModel()).isModelLinearized()) {
4315:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4318 throw std::runtime_error(
"mueeZHcc called with a class whose parent is not NPbase");
4323 if ((this->
getModel()).isModelLinearized()) {
4331:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4334 throw std::runtime_error(
"mueeZHss called with a class whose parent is not NPbase");
4339 if ((this->
getModel()).isModelLinearized()) {
4347:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4350 throw std::runtime_error(
"mueeZHgg called with a class whose parent is not NPbase");
4355 if ((this->
getModel()).isModelLinearized()) {
4363:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4366 throw std::runtime_error(
"mueeZHWW called with a class whose parent is not NPbase");
4371 if ((this->
getModel()).isModelLinearized()) {
4379:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4382 throw std::runtime_error(
"mueeZHtautau called with a class whose parent is not NPbase");
4387 if ((this->
getModel()).isModelLinearized()) {
4395:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4398 throw std::runtime_error(
"mueeZHZZ called with a class whose parent is not NPbase");
4403 if ((this->
getModel()).isModelLinearized()) {
4411:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4414 throw std::runtime_error(
"mueeZHZga called with a class whose parent is not NPbase");
4419 if ((this->
getModel()).isModelLinearized()) {
4427:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4430 throw std::runtime_error(
"mueeZHgaga called with a class whose parent is not NPbase");
4435 if ((this->
getModel()).isModelLinearized()) {
4443:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4446 throw std::runtime_error(
"mueeZHmumu called with a class whose parent is not NPbase");
4451 if ((this->
getModel()).isModelLinearized()) {
4459:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4462 throw std::runtime_error(
"mueeZHBRinv called with a class whose parent is not NPbase");
4473:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4476 throw std::runtime_error(
"mueeZHinv called with a class whose parent is not NPbase");
4482 if ((this->
getModel()).isModelLinearized()) {
4494 throw std::runtime_error(
"mueeWBFbb called with a class whose parent is not NPbase");
4500 if ((this->
getModel()).isModelLinearized()) {
4508:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4511 throw std::runtime_error(
"mueeWBFbbPol called with a class whose parent is not NPbase");
4517 if ((this->
getModel()).isModelLinearized()) {
4528 throw std::runtime_error(
"mueeWBFcc called with a class whose parent is not NPbase");
4534 if ((this->
getModel()).isModelLinearized()) {
4545 throw std::runtime_error(
"mueeWBFgg called with a class whose parent is not NPbase");
4551 if ((this->
getModel()).isModelLinearized()) {
4562 throw std::runtime_error(
"mueeWBFWW called with a class whose parent is not NPbase");
4568 if ((this->
getModel()).isModelLinearized()) {
4579 throw std::runtime_error(
"mueeWBFtautau called with a class whose parent is not NPbase");
4585 if ((this->
getModel()).isModelLinearized()) {
4596 throw std::runtime_error(
"mueeWBFZZ called with a class whose parent is not NPbase");
4602 if ((this->
getModel()).isModelLinearized()) {
4613 throw std::runtime_error(
"mueeWBFZga called with a class whose parent is not NPbase");
4619 if ((this->
getModel()).isModelLinearized()) {
4630 throw std::runtime_error(
"mueeWBFgaga called with a class whose parent is not NPbase");
4636 if ((this->
getModel()).isModelLinearized()) {
4647 throw std::runtime_error(
"mueeWBFmumu called with a class whose parent is not NPbase");
4653 if ((this->
getModel()).isModelLinearized()) {
4664 throw std::runtime_error(
"mueeHvvbb called with a class whose parent is not NPbase");
4670 if ((this->
getModel()).isModelLinearized()) {
4678:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4681 throw std::runtime_error(
"mueeHvvbbPol called with a class whose parent is not NPbase");
4687 if ((this->
getModel()).isModelLinearized()) {
4698 throw std::runtime_error(
"mueeHvvcc called with a class whose parent is not NPbase");
4704 if ((this->
getModel()).isModelLinearized()) {
4712:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4715 throw std::runtime_error(
"mueeHvvccPol called with a class whose parent is not NPbase");
4721 if ((this->
getModel()).isModelLinearized()) {
4733 throw std::runtime_error(
"mueeHvvss called with a class whose parent is not NPbase");
4739 if ((this->
getModel()).isModelLinearized()) {
4747:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4750 throw std::runtime_error(
"mueeHvvssPol called with a class whose parent is not NPbase");
4756 if ((this->
getModel()).isModelLinearized()) {
4768 throw std::runtime_error(
"mueeHvvgg called with a class whose parent is not NPbase");
4774 if ((this->
getModel()).isModelLinearized()) {
4782:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4785 throw std::runtime_error(
"mueeHvvggPol called with a class whose parent is not NPbase");
4791 if ((this->
getModel()).isModelLinearized()) {
4802 throw std::runtime_error(
"mueeHvvWW called with a class whose parent is not NPbase");
4808 if ((this->
getModel()).isModelLinearized()) {
4816:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4819 throw std::runtime_error(
"mueeHvvWWPol called with a class whose parent is not NPbase");
4825 if ((this->
getModel()).isModelLinearized()) {
4836 throw std::runtime_error(
"mueeHvvtautau called with a class whose parent is not NPbase");
4842 if ((this->
getModel()).isModelLinearized()) {
4850:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4853 throw std::runtime_error(
"mueeHvvtautauPol called with a class whose parent is not NPbase");
4859 if ((this->
getModel()).isModelLinearized()) {
4870 throw std::runtime_error(
"mueeHvvZZ called with a class whose parent is not NPbase");
4876 if ((this->
getModel()).isModelLinearized()) {
4884:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4887 throw std::runtime_error(
"mueeHvvZZPol called with a class whose parent is not NPbase");
4893 if ((this->
getModel()).isModelLinearized()) {
4904 throw std::runtime_error(
"mueeHvvZga called with a class whose parent is not NPbase");
4910 if ((this->
getModel()).isModelLinearized()) {
4918:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4921 throw std::runtime_error(
"mueeHvvZgaPol called with a class whose parent is not NPbase");
4927 if ((this->
getModel()).isModelLinearized()) {
4938 throw std::runtime_error(
"mueeHvvgaga called with a class whose parent is not NPbase");
4944 if ((this->
getModel()).isModelLinearized()) {
4952:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4955 throw std::runtime_error(
"mueeHvvgagaPol called with a class whose parent is not NPbase");
4961 if ((this->
getModel()).isModelLinearized()) {
4972 throw std::runtime_error(
"mueeHvvmumu called with a class whose parent is not NPbase");
4978 if ((this->
getModel()).isModelLinearized()) {
4986:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4989 throw std::runtime_error(
"mueeHvvmumuPol called with a class whose parent is not NPbase");
4995 if ((this->
getModel()).isModelLinearized()) {
5006 throw std::runtime_error(
"mueeZBFbb called with a class whose parent is not NPbase");
5011 if ((this->
getModel()).isModelLinearized()) {
5019:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5022 throw std::runtime_error(
"mueeZBFbbPol called with a class whose parent is not NPbase");
5027 if ((this->
getModel()).isModelLinearized()) {
5038 throw std::runtime_error(
"mueettHbb called with a class whose parent is not NPbase");
5043 if ((this->
getModel()).isModelLinearized()) {
5051:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5054 throw std::runtime_error(
"mueettHbbPol called with a class whose parent is not NPbase");
5059 if ((this->
getModel()).isModelLinearized()) {
5074 throw std::runtime_error(
"mummZH called with a class whose parent is not NPbase");
5087 throw std::runtime_error(
"mummHvv called with a class whose parent is not NPbase");
5100 throw std::runtime_error(
"mummHmm called with a class whose parent is not NPbase");
5113 throw std::runtime_error(
"mummttH called with a class whose parent is not NPbase");
5130 throw std::runtime_error(
"mummHbb called with a class whose parent is not NPbase");
5135 if ((this->
getModel()).isModelLinearized()) {
5146 throw std::runtime_error(
"mummHcc called with a class whose parent is not NPbase");
5151 if ((this->
getModel()).isModelLinearized()) {
5162 throw std::runtime_error(
"mummHgg called with a class whose parent is not NPbase");
5167 if ((this->
getModel()).isModelLinearized()) {
5178 throw std::runtime_error(
"mummHcc called with a class whose parent is not NPbase");
5183 if ((this->
getModel()).isModelLinearized()) {
5194 throw std::runtime_error(
"mummHtautau called with a class whose parent is not NPbase");
5199 if ((this->
getModel()).isModelLinearized()) {
5210 throw std::runtime_error(
"mummHZZ called with a class whose parent is not NPbase");
5215 if ((this->
getModel()).isModelLinearized()) {
5226 throw std::runtime_error(
"mummHZga called with a class whose parent is not NPbase");
5231 if ((this->
getModel()).isModelLinearized()) {
5242 throw std::runtime_error(
"mummHgaga called with a class whose parent is not NPbase");
5247 if ((this->
getModel()).isModelLinearized()) {
5258 throw std::runtime_error(
"mummHmumu called with a class whose parent is not NPbase");
5263 if ((this->
getModel()).isModelLinearized()) {
5276 throw std::runtime_error(
"mummZHbb called with a class whose parent is not NPbase");
5281 if ((this->
getModel()).isModelLinearized()) {
5292 throw std::runtime_error(
"mummZHcc called with a class whose parent is not NPbase");
5297 if ((this->
getModel()).isModelLinearized()) {
5308 throw std::runtime_error(
"mummZHgg called with a class whose parent is not NPbase");
5313 if ((this->
getModel()).isModelLinearized()) {
5324 throw std::runtime_error(
"mummZHcc called with a class whose parent is not NPbase");
5329 if ((this->
getModel()).isModelLinearized()) {
5340 throw std::runtime_error(
"mummZHtautau called with a class whose parent is not NPbase");
5345 if ((this->
getModel()).isModelLinearized()) {
5356 throw std::runtime_error(
"mummZHZZ called with a class whose parent is not NPbase");
5361 if ((this->
getModel()).isModelLinearized()) {
5372 throw std::runtime_error(
"mummZHZga called with a class whose parent is not NPbase");
5377 if ((this->
getModel()).isModelLinearized()) {
5388 throw std::runtime_error(
"mummZHgaga called with a class whose parent is not NPbase");
5393 if ((this->
getModel()).isModelLinearized()) {
5404 throw std::runtime_error(
"mummZHmumu called with a class whose parent is not NPbase");
5409 if ((this->
getModel()).isModelLinearized()) {
5422 throw std::runtime_error(
"mummHvvbb called with a class whose parent is not NPbase");
5427 if ((this->
getModel()).isModelLinearized()) {
5438 throw std::runtime_error(
"mummHvvcc called with a class whose parent is not NPbase");
5443 if ((this->
getModel()).isModelLinearized()) {
5454 throw std::runtime_error(
"mummHvvgg called with a class whose parent is not NPbase");
5459 if ((this->
getModel()).isModelLinearized()) {
5470 throw std::runtime_error(
"mummHvvcc called with a class whose parent is not NPbase");
5475 if ((this->
getModel()).isModelLinearized()) {
5486 throw std::runtime_error(
"mummHvvtautau called with a class whose parent is not NPbase");
5491 if ((this->
getModel()).isModelLinearized()) {
5502 throw std::runtime_error(
"mummHvvZZ called with a class whose parent is not NPbase");
5507 if ((this->
getModel()).isModelLinearized()) {
5518 throw std::runtime_error(
"mummHvvZga called with a class whose parent is not NPbase");
5523 if ((this->
getModel()).isModelLinearized()) {
5534 throw std::runtime_error(
"mummHvvgaga called with a class whose parent is not NPbase");
5539 if ((this->
getModel()).isModelLinearized()) {
5550 throw std::runtime_error(
"mummHvvmumu called with a class whose parent is not NPbase");
5555 if ((this->
getModel()).isModelLinearized()) {
5568 throw std::runtime_error(
"mummHmmbb called with a class whose parent is not NPbase");
5573 if ((this->
getModel()).isModelLinearized()) {
5584 throw std::runtime_error(
"mummHmmcc called with a class whose parent is not NPbase");
5589 if ((this->
getModel()).isModelLinearized()) {
5600 throw std::runtime_error(
"mummHmmgg called with a class whose parent is not NPbase");
5605 if ((this->
getModel()).isModelLinearized()) {
5616 throw std::runtime_error(
"mummHmmcc called with a class whose parent is not NPbase");
5621 if ((this->
getModel()).isModelLinearized()) {
5632 throw std::runtime_error(
"mummHmmtautau called with a class whose parent is not NPbase");
5637 if ((this->
getModel()).isModelLinearized()) {
5648 throw std::runtime_error(
"mummHmmZZ called with a class whose parent is not NPbase");
5653 if ((this->
getModel()).isModelLinearized()) {
5664 throw std::runtime_error(
"mummHmmZga called with a class whose parent is not NPbase");
5669 if ((this->
getModel()).isModelLinearized()) {
5680 throw std::runtime_error(
"mummHmmgaga called with a class whose parent is not NPbase");
5685 if ((this->
getModel()).isModelLinearized()) {
5696 throw std::runtime_error(
"mummHmmmumu called with a class whose parent is not NPbase");
5701 if ((this->
getModel()).isModelLinearized()) {
5713 throw std::runtime_error(
"mummttHbb called with a class whose parent is not NPbase");
5718 if ((this->
getModel()).isModelLinearized()) {
5729 throw std::runtime_error(
"mummttHcc called with a class whose parent is not NPbase");
5734 if ((this->
getModel()).isModelLinearized()) {
5745 throw std::runtime_error(
"mummttHgg called with a class whose parent is not NPbase");
5750 if ((this->
getModel()).isModelLinearized()) {
5761 throw std::runtime_error(
"mummttHcc called with a class whose parent is not NPbase");
5766 if ((this->
getModel()).isModelLinearized()) {
5777 throw std::runtime_error(
"mummttHtautau called with a class whose parent is not NPbase");
5782 if ((this->
getModel()).isModelLinearized()) {
5793 throw std::runtime_error(
"mummttHZZ called with a class whose parent is not NPbase");
5798 if ((this->
getModel()).isModelLinearized()) {
5809 throw std::runtime_error(
"mummttHZga called with a class whose parent is not NPbase");
5814 if ((this->
getModel()).isModelLinearized()) {
5825 throw std::runtime_error(
"mummttHgaga called with a class whose parent is not NPbase");
5830 if ((this->
getModel()).isModelLinearized()) {
5841 throw std::runtime_error(
"mummttHmumu called with a class whose parent is not NPbase");
5846 if ((this->
getModel()).isModelLinearized()) {
5860 throw std::runtime_error(
"mummHbbNWA called with a class whose parent is not NPbase");
5865 if ((this->
getModel()).isModelLinearized()) {
5876 throw std::runtime_error(
"mummHccNWA called with a class whose parent is not NPbase");
5881 if ((this->
getModel()).isModelLinearized()) {
5892 throw std::runtime_error(
"mummHggNWA called with a class whose parent is not NPbase");
5897 if ((this->
getModel()).isModelLinearized()) {
5908 throw std::runtime_error(
"mummHccNWA called with a class whose parent is not NPbase");
5913 if ((this->
getModel()).isModelLinearized()) {
5924 throw std::runtime_error(
"mummHtautauNWA called with a class whose parent is not NPbase");
5929 if ((this->
getModel()).isModelLinearized()) {
5940 throw std::runtime_error(
"mummHZZNWA called with a class whose parent is not NPbase");
5945 if ((this->
getModel()).isModelLinearized()) {
5956 throw std::runtime_error(
"mummHZgaNWA called with a class whose parent is not NPbase");
5961 if ((this->
getModel()).isModelLinearized()) {
5972 throw std::runtime_error(
"mummHgagaNWA called with a class whose parent is not NPbase");
5977 if ((this->
getModel()).isModelLinearized()) {
5988 throw std::runtime_error(
"mummHmumuNWA called with a class whose parent is not NPbase");
5993 if ((this->
getModel()).isModelLinearized()) {
6007 throw std::runtime_error(
"muepWBFbb called with a class whose parent is not NPbase");
6013 if ((this->
getModel()).isModelLinearized()) {
6024 throw std::runtime_error(
"muepWBFcc called with a class whose parent is not NPbase");
6030 if ((this->
getModel()).isModelLinearized()) {
6041 throw std::runtime_error(
"muepWBFgg called with a class whose parent is not NPbase");
6047 if ((this->
getModel()).isModelLinearized()) {
6058 throw std::runtime_error(
"muepWBFWW2l2v called with a class whose parent is not NPbase");
6064 if ((this->
getModel()).isModelLinearized()) {
6075 throw std::runtime_error(
"muepWBFZZ4l called with a class whose parent is not NPbase");
6081 if ((this->
getModel()).isModelLinearized()) {
6092 throw std::runtime_error(
"muepWBFgaga called with a class whose parent is not NPbase");
6098 if ((this->
getModel()).isModelLinearized()) {
6109 throw std::runtime_error(
"muepWBFtautau called with a class whose parent is not NPbase");
6115 if ((this->
getModel()).isModelLinearized()) {
6126 throw std::runtime_error(
"muepZBFbb called with a class whose parent is not NPbase");
6132 if ((this->
getModel()).isModelLinearized()) {
6143 throw std::runtime_error(
"muepZBFcc called with a class whose parent is not NPbase");
6149 if ((this->
getModel()).isModelLinearized()) {
6160 throw std::runtime_error(
"muepZBFgg called with a class whose parent is not NPbase");
6166 if ((this->
getModel()).isModelLinearized()) {
6177 throw std::runtime_error(
"muepZBFWW2l2v called with a class whose parent is not NPbase");
6183 if ((this->
getModel()).isModelLinearized()) {
6194 throw std::runtime_error(
"muepZBFZZ4l called with a class whose parent is not NPbase");
6200 if ((this->
getModel()).isModelLinearized()) {
6211 throw std::runtime_error(
"muepZBFgaga called with a class whose parent is not NPbase");
6217 if ((this->
getModel()).isModelLinearized()) {
6228 throw std::runtime_error(
"muepZBFtautau called with a class whose parent is not NPbase");
6234 if ((this->
getModel()).isModelLinearized()) {
6254 throw std::runtime_error(
"STXS_0_qqH called with a class whose parent is not NPbase");
6272 throw std::runtime_error(
"STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6278 if ((this->
getModel()).isModelLinearized()) {
6290 throw std::runtime_error(
"STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6296 if ((this->
getModel()).isModelLinearized()) {
6308 throw std::runtime_error(
"STXSggH0j4l called with a class whose parent is not NPbase");
6314 if ((this->
getModel()).isModelLinearized()) {
6325 throw std::runtime_error(
"STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6331 if ((this->
getModel()).isModelLinearized()) {
6342 throw std::runtime_error(
"STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6348 if ((this->
getModel()).isModelLinearized()) {
6359 throw std::runtime_error(
"STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6365 if ((this->
getModel()).isModelLinearized()) {
6376 throw std::runtime_error(
"STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6382 if ((this->
getModel()).isModelLinearized()) {
6393 throw std::runtime_error(
"STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6399 if ((this->
getModel()).isModelLinearized()) {
6411 throw std::runtime_error(
"STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6417 if ((this->
getModel()).isModelLinearized()) {
6429 throw std::runtime_error(
"STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6435 if ((this->
getModel()).isModelLinearized()) {
6447 throw std::runtime_error(
"STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6453 if ((this->
getModel()).isModelLinearized()) {
6465 throw std::runtime_error(
"STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6471 if ((this->
getModel()).isModelLinearized()) {
6483 throw std::runtime_error(
"STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6489 if ((this->
getModel()).isModelLinearized()) {
6501 throw std::runtime_error(
"STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6507 if ((this->
getModel()).isModelLinearized()) {
6520 throw std::runtime_error(
"STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6526 if ((this->
getModel()).isModelLinearized()) {
6539 throw std::runtime_error(
"STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6545 if ((this->
getModel()).isModelLinearized()) {
6558 throw std::runtime_error(
"STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6564 if ((this->
getModel()).isModelLinearized()) {
6576 throw std::runtime_error(
"STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6582 if ((this->
getModel()).isModelLinearized()) {
6594 throw std::runtime_error(
"STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6600 if ((this->
getModel()).isModelLinearized()) {
6611 throw std::runtime_error(
"STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6617 if ((this->
getModel()).isModelLinearized()) {
6629 throw std::runtime_error(
"STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6635 if ((this->
getModel()).isModelLinearized()) {
6648 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6654 if ((this->
getModel()).isModelLinearized()) {
6667 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6673 if ((this->
getModel()).isModelLinearized()) {
6685 throw std::runtime_error(
"STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6691 if ((this->
getModel()).isModelLinearized()) {
6702 throw std::runtime_error(
"STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6708 if ((this->
getModel()).isModelLinearized()) {
6719 throw std::runtime_error(
"STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6725 if ((this->
getModel()).isModelLinearized()) {
6737 throw std::runtime_error(
"STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6743 if ((this->
getModel()).isModelLinearized()) {
6755 throw std::runtime_error(
"STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6761 if ((this->
getModel()).isModelLinearized()) {
6773 throw std::runtime_error(
"STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6779 if ((this->
getModel()).isModelLinearized()) {
6790 throw std::runtime_error(
"STXSttHtH4l called with a class whose parent is not NPbase");
6796 if ((this->
getModel()).isModelLinearized()) {
6808 throw std::runtime_error(
"STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6814 if ((this->
getModel()).isModelLinearized()) {
6826 throw std::runtime_error(
"STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6832 if ((this->
getModel()).isModelLinearized()) {
6845 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6851 if ((this->
getModel()).isModelLinearized()) {
6864 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6870 if ((this->
getModel()).isModelLinearized()) {
6882 throw std::runtime_error(
"STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6888 if ((this->
getModel()).isModelLinearized()) {
6899 throw std::runtime_error(
"STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6905 if ((this->
getModel()).isModelLinearized()) {
6916 throw std::runtime_error(
"STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6922 if ((this->
getModel()).isModelLinearized()) {
6934 throw std::runtime_error(
"STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6940 if ((this->
getModel()).isModelLinearized()) {
6952 throw std::runtime_error(
"STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6958 if ((this->
getModel()).isModelLinearized()) {
6970 throw std::runtime_error(
"STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6976 if ((this->
getModel()).isModelLinearized()) {
6988 throw std::runtime_error(
"STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6994 if ((this->
getModel()).isModelLinearized()) {
7006 throw std::runtime_error(
"STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7012 if ((this->
getModel()).isModelLinearized()) {
7024 throw std::runtime_error(
"STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7030 if ((this->
getModel()).isModelLinearized()) {
7042 throw std::runtime_error(
"STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7048 if ((this->
getModel()).isModelLinearized()) {
7060 throw std::runtime_error(
"STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7066 if ((this->
getModel()).isModelLinearized()) {
7078 throw std::runtime_error(
"STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
7084 if ((this->
getModel()).isModelLinearized()) {
7096 throw std::runtime_error(
"STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7102 if ((this->
getModel()).isModelLinearized()) {
7114 throw std::runtime_error(
"STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7120 if ((this->
getModel()).isModelLinearized()) {
7132 throw std::runtime_error(
"STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7138 if ((this->
getModel()).isModelLinearized()) {
7150 throw std::runtime_error(
"STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7156 if ((this->
getModel()).isModelLinearized()) {
7170:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7173 throw std::runtime_error(
"STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7179 double BrHXXRatio = 1.0;
7189 throw std::runtime_error(
"STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7192 if ((this->
getModel()).isModelLinearized()) {
7202:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7205 throw std::runtime_error(
"STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7211 double BrHXXRatio = 1.0;
7221 throw std::runtime_error(
"STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7224 if ((this->
getModel()).isModelLinearized()) {
7234:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7237 throw std::runtime_error(
"STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7243 double BrHXXRatio = 1.0;
7253 throw std::runtime_error(
"STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7256 if ((this->
getModel()).isModelLinearized()) {
7266:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7269 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7275 double BrHXXRatio = 1.0;
7285 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7288 if ((this->
getModel()).isModelLinearized()) {
7299:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7302 throw std::runtime_error(
"STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7309 double weight = 1.0;
7312 double muProd1 = muProd -1.0;
7313 double muProd2 = 0.0;
7315 double BrHXXRatio = 1.0;
7316 double dBrHXXRatio1 = 0.0;
7317 double dBrHXXRatio2 = 0.0;
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7336 throw std::runtime_error(
"STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7340 if ((this->
getModel()).isModelLinearized()){
7341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7342 }
else if((this->
getModel()).isModelNPquadratic()){
7343 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7345 return weight*(muProd)*(BrHXXRatio);
7357:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7360 throw std::runtime_error(
"STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7367 double weight = 1.0;
7370 double muProd1 = muProd -1.0;
7371 double muProd2 = 0.0;
7374 double BrHXXRatio = 1.0;
7375 double dBrHXXRatio1 = 0.0;
7376 double dBrHXXRatio2 = 0.0;
7382 dBrHXXRatio1 = BrHXXRatio - 1.0;
7386 dBrHXXRatio1 = BrHXXRatio - 1.0;
7390 dBrHXXRatio1 = BrHXXRatio - 1.0;
7394 dBrHXXRatio1 = BrHXXRatio - 1.0;
7398 dBrHXXRatio1 = BrHXXRatio - 1.0;
7402 dBrHXXRatio1 = BrHXXRatio - 1.0;
7406 dBrHXXRatio1 = BrHXXRatio - 1.0;
7409 throw std::runtime_error(
"STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7413 if ((this->
getModel()).isModelLinearized()){
7414 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7415 }
else if((this->
getModel()).isModelNPquadratic()){
7416 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7418 return weight*(muProd)*(BrHXXRatio);
7429:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7432 throw std::runtime_error(
"STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7439 double weight = 1.0;
7442 double muProd1 = muProd -1.0;
7443 double muProd2 = 0.0;
7446 double BrHXXRatio = 1.0;
7447 double dBrHXXRatio1 = 0.0;
7448 double dBrHXXRatio2 = 0.0;
7454 dBrHXXRatio1 = BrHXXRatio - 1.0;
7458 dBrHXXRatio1 = BrHXXRatio - 1.0;
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7481 throw std::runtime_error(
"STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7485 if ((this->
getModel()).isModelLinearized()){
7486 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7487 }
else if((this->
getModel()).isModelNPquadratic()){
7488 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7490 return weight*(muProd)*(BrHXXRatio);
7502:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7505 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7512 double weight = 1.0;
7517 double muProd1 = muProd -1.0;
7518 double muProd2 = 0.0;
7521 double BrHXXRatio = 1.0;
7522 double dBrHXXRatio1 = 0.0;
7523 double dBrHXXRatio2 = 0.0;
7526 weight = (6.6369 + 20.642);
7529 dBrHXXRatio1 = BrHXXRatio - 1.0;
7533 dBrHXXRatio1 = BrHXXRatio - 1.0;
7537 dBrHXXRatio1 = BrHXXRatio - 1.0;
7541 dBrHXXRatio1 = BrHXXRatio - 1.0;
7545 dBrHXXRatio1 = BrHXXRatio - 1.0;
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7556 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7560 if ((this->
getModel()).isModelLinearized()){
7561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7562 }
else if((this->
getModel()).isModelNPquadratic()){
7563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7565 return weight*(muProd)*(BrHXXRatio);
7577:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7580 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7587 double weight = 1.0;
7591 double muProd1 = muProd -1.0;
7592 double muProd2 = 0.0;
7595 double BrHXXRatio = 1.0;
7596 double dBrHXXRatio1 = 0.0;
7597 double dBrHXXRatio2 = 0.0;
7603 dBrHXXRatio1 = BrHXXRatio - 1.0;
7607 dBrHXXRatio1 = BrHXXRatio - 1.0;
7611 dBrHXXRatio1 = BrHXXRatio - 1.0;
7615 dBrHXXRatio1 = BrHXXRatio - 1.0;
7619 dBrHXXRatio1 = BrHXXRatio - 1.0;
7623 dBrHXXRatio1 = BrHXXRatio - 1.0;
7627 dBrHXXRatio1 = BrHXXRatio - 1.0;
7630 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7634 if ((this->
getModel()).isModelLinearized()){
7635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7636 }
else if((this->
getModel()).isModelNPquadratic()){
7637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7639 return weight*(muProd)*(BrHXXRatio);
7654:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7657 throw std::runtime_error(
"STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7664 double weight = 1.0;
7666 double muProd1 = muProd -1.0;
7667 double muProd2 = 0.0;
7670 double BrHXXRatio = 1.0;
7671 double dBrHXXRatio1 = 0.0;
7672 double dBrHXXRatio2 = 0.0;
7678 dBrHXXRatio1 = BrHXXRatio - 1.0;
7682 dBrHXXRatio1 = BrHXXRatio - 1.0;
7686 dBrHXXRatio1 = BrHXXRatio - 1.0;
7690 dBrHXXRatio1 = BrHXXRatio - 1.0;
7694 dBrHXXRatio1 = BrHXXRatio - 1.0;
7698 dBrHXXRatio1 = BrHXXRatio - 1.0;
7702 dBrHXXRatio1 = BrHXXRatio - 1.0;
7705 throw std::runtime_error(
"STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7709 if ((this->
getModel()).isModelLinearized()){
7710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7711 }
else if((this->
getModel()).isModelNPquadratic()){
7712 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7714 return weight*(muProd)*(BrHXXRatio);
7723:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7726 throw std::runtime_error(
"STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7733 double weight = 1.0;
7735 double muProd1 = muProd -1.0;
7736 double muProd2 = 0.0;
7739 double BrHXXRatio = 1.0;
7740 double dBrHXXRatio1 = 0.0;
7741 double dBrHXXRatio2 = 0.0;
7747 dBrHXXRatio1 = BrHXXRatio - 1.0;
7751 dBrHXXRatio1 = BrHXXRatio - 1.0;
7755 dBrHXXRatio1 = BrHXXRatio - 1.0;
7759 dBrHXXRatio1 = BrHXXRatio - 1.0;
7763 dBrHXXRatio1 = BrHXXRatio - 1.0;
7767 dBrHXXRatio1 = BrHXXRatio - 1.0;
7771 dBrHXXRatio1 = BrHXXRatio - 1.0;
7774 throw std::runtime_error(
"STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7778 if ((this->
getModel()).isModelLinearized()){
7779 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7780 }
else if((this->
getModel()).isModelNPquadratic()){
7781 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7783 return weight*(muProd)*(BrHXXRatio);
7792:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7795 throw std::runtime_error(
"STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7802 double weight = 1.0;
7804 double muProd1 = muProd -1.0;
7805 double muProd2 = 0.0;
7808 double BrHXXRatio = 1.0;
7809 double dBrHXXRatio1 = 0.0;
7810 double dBrHXXRatio2 = 0.0;
7816 dBrHXXRatio1 = BrHXXRatio - 1.0;
7820 dBrHXXRatio1 = BrHXXRatio - 1.0;
7824 dBrHXXRatio1 = BrHXXRatio - 1.0;
7828 dBrHXXRatio1 = BrHXXRatio - 1.0;
7832 dBrHXXRatio1 = BrHXXRatio - 1.0;
7836 dBrHXXRatio1 = BrHXXRatio - 1.0;
7840 dBrHXXRatio1 = BrHXXRatio - 1.0;
7843 throw std::runtime_error(
"STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7847 if ((this->
getModel()).isModelLinearized()){
7848 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7849 }
else if((this->
getModel()).isModelNPquadratic()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7852 return weight*(muProd)*(BrHXXRatio);
7863:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7866 throw std::runtime_error(
"STXS12_ggH_pTH60_200_Nj1 called with a class whose parent is not NPbase");
7873 double weight = 1.0;
7876 )/(4.50294+0.74712);
7877 double muProd1 = muProd -1.0;
7878 double muProd2 = 0.0;
7881 double BrHXXRatio = 1.0;
7882 double dBrHXXRatio1 = 0.0;
7883 double dBrHXXRatio2 = 0.0;
7886 weight = (4.50294+0.74712);
7889 dBrHXXRatio1 = BrHXXRatio - 1.0;
7893 dBrHXXRatio1 = BrHXXRatio - 1.0;
7897 dBrHXXRatio1 = BrHXXRatio - 1.0;
7901 dBrHXXRatio1 = BrHXXRatio - 1.0;
7905 dBrHXXRatio1 = BrHXXRatio - 1.0;
7909 dBrHXXRatio1 = BrHXXRatio - 1.0;
7913 dBrHXXRatio1 = BrHXXRatio - 1.0;
7916 throw std::runtime_error(
"STXS12_ggH_pTH60_200_Nj1 called with invalid argument for final state in fstate_i");
7920 if ((this->
getModel()).isModelLinearized()){
7921 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7922 }
else if((this->
getModel()).isModelNPquadratic()){
7923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7925 return weight*(muProd)*(BrHXXRatio);
7934:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7937 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7946 double weight = 1.0;
7949 double muProd1 = muProd -1.0;
7950 double muProd2 = 0.0;
7953 double BrHXXRatio = 1.0;
7954 double dBrHXXRatio1 = 0.0;
7955 double dBrHXXRatio2 = 0.0;
7964 dBrHXXRatio1 = BrHXXRatio - 1.0;
7968 dBrHXXRatio1 = BrHXXRatio - 1.0;
7972 dBrHXXRatio1 = BrHXXRatio - 1.0;
7976 dBrHXXRatio1 = BrHXXRatio - 1.0;
7980 dBrHXXRatio1 = BrHXXRatio - 1.0;
7984 dBrHXXRatio1 = BrHXXRatio - 1.0;
7988 dBrHXXRatio1 = BrHXXRatio - 1.0;
7991 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7997 if ((this->
getModel()).isModelLinearized()){
7998 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7999 }
else if((this->
getModel()).isModelNPquadratic()){
8000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8002 return weight*(muProd)*(BrHXXRatio);
8009:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8012 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
8020 double weight = 1.0;
8024 double muProd1 = muProd -1.0;
8025 double muProd2 = 0.0;
8028 double BrHXXRatio = 1.0;
8029 double dBrHXXRatio1 = 0.0;
8030 double dBrHXXRatio2 = 0.0;
8039 dBrHXXRatio1 = BrHXXRatio - 1.0;
8043 dBrHXXRatio1 = BrHXXRatio - 1.0;
8047 dBrHXXRatio1 = BrHXXRatio - 1.0;
8051 dBrHXXRatio1 = BrHXXRatio - 1.0;
8055 dBrHXXRatio1 = BrHXXRatio - 1.0;
8059 dBrHXXRatio1 = BrHXXRatio - 1.0;
8063 dBrHXXRatio1 = BrHXXRatio - 1.0;
8066 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
8070 if ((this->
getModel()).isModelLinearized()){
8071 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8072 }
else if((this->
getModel()).isModelNPquadratic()){
8073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8075 return weight*(muProd)*(BrHXXRatio);
8087:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8090 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
8097 double weight = 1.0;
8103 double muProd1 = muProd -1.0;
8104 double muProd2 = 0.0;
8107 double BrHXXRatio = 1.0;
8108 double dBrHXXRatio1 = 0.0;
8109 double dBrHXXRatio2 = 0.0;
8120 dBrHXXRatio1 = BrHXXRatio - 1.0;
8124 dBrHXXRatio1 = BrHXXRatio - 1.0;
8128 dBrHXXRatio1 = BrHXXRatio - 1.0;
8132 dBrHXXRatio1 = BrHXXRatio - 1.0;
8136 dBrHXXRatio1 = BrHXXRatio - 1.0;
8140 dBrHXXRatio1 = BrHXXRatio - 1.0;
8144 dBrHXXRatio1 = BrHXXRatio - 1.0;
8147 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
8151 if ((this->
getModel()).isModelLinearized()){
8152 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8153 }
else if((this->
getModel()).isModelNPquadratic()){
8154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8156 return weight*(muProd)*(BrHXXRatio);
8168:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8171 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
8178 double weight = 1.0;
8180 double muProd1 = muProd -1.0;
8181 double muProd2 = 0.0;
8184 double BrHXXRatio = 1.0;
8185 double dBrHXXRatio1 = 0.0;
8186 double dBrHXXRatio2 = 0.0;
8192 dBrHXXRatio1 = BrHXXRatio - 1.0;
8196 dBrHXXRatio1 = BrHXXRatio - 1.0;
8200 dBrHXXRatio1 = BrHXXRatio - 1.0;
8204 dBrHXXRatio1 = BrHXXRatio - 1.0;
8208 dBrHXXRatio1 = BrHXXRatio - 1.0;
8212 dBrHXXRatio1 = BrHXXRatio - 1.0;
8216 dBrHXXRatio1 = BrHXXRatio - 1.0;
8219 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
8223 if ((this->
getModel()).isModelLinearized()){
8224 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8225 }
else if((this->
getModel()).isModelNPquadratic()){
8226 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8228 return weight*(muProd)*(BrHXXRatio);
8238:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8241 throw std::runtime_error(
"STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8248 double weight = 1.0;
8256 double muProd1 = muProd -1.0;
8257 double muProd2 = 0.0;
8260 double BrHXXRatio = 1.0;
8261 double dBrHXXRatio1 = 0.0;
8262 double dBrHXXRatio2 = 0.0;
8268 dBrHXXRatio1 = BrHXXRatio - 1.0;
8272 dBrHXXRatio1 = BrHXXRatio - 1.0;
8276 dBrHXXRatio1 = BrHXXRatio - 1.0;
8280 dBrHXXRatio1 = BrHXXRatio - 1.0;
8284 dBrHXXRatio1 = BrHXXRatio - 1.0;
8288 dBrHXXRatio1 = BrHXXRatio - 1.0;
8292 dBrHXXRatio1 = BrHXXRatio - 1.0;
8295 throw std::runtime_error(
"STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8299 if ((this->
getModel()).isModelLinearized()){
8300 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8301 }
else if((this->
getModel()).isModelNPquadratic()){
8302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8304 return weight*(muProd)*(BrHXXRatio);
8313:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8316 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8322 double BrHXXRatio = 1.0;
8332 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8335 if ((this->
getModel()).isModelLinearized()) {
8345:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8349 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8355 double BrHXXRatio = 1.0;
8365 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8368 if ((this->
getModel()).isModelLinearized()) {
8378:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8381 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8387 double BrHXXRatio = 1.0;
8397 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8400 if ((this->
getModel()).isModelLinearized()) {
8410:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8413 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8419 double BrHXXRatio = 1.0;
8429 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8432 if ((this->
getModel()).isModelLinearized()) {
8447:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8450 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8460 double weight = 1.0;
8472 )/(1.24+2.00+0.94321+0.87751);
8473 double muProd1 = muProd -1.0;
8474 double muProd2 = 0.0;
8477 double BrHXXRatio = 1.0;
8478 double dBrHXXRatio1 = 0.0;
8479 double dBrHXXRatio2 = 0.0;
8482 weight = (1.24+2.00+0.94321+0.87751);
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8497 dBrHXXRatio1 = BrHXXRatio - 1.0;
8501 dBrHXXRatio1 = BrHXXRatio - 1.0;
8505 dBrHXXRatio1 = BrHXXRatio - 1.0;
8509 dBrHXXRatio1 = BrHXXRatio - 1.0;
8512 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8516 if ((this->
getModel()).isModelLinearized()){
8517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8518 }
else if((this->
getModel()).isModelNPquadratic()){
8519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8521 return weight*(muProd)*(BrHXXRatio);
8537:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8540 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8547 double weight = 1.0;
8552 /(0.45825 + 0.10632 + 0.017974);
8553 double muProd1 = muProd -1.0;
8554 double muProd2 = 0.0;
8557 double BrHXXRatio = 1.0;
8558 double dBrHXXRatio1 = 0.0;
8559 double dBrHXXRatio2 = 0.0;
8562 weight = (0.45825 + 0.10632 + 0.017974);
8565 dBrHXXRatio1 = BrHXXRatio - 1.0;
8569 dBrHXXRatio1 = BrHXXRatio - 1.0;
8573 dBrHXXRatio1 = BrHXXRatio - 1.0;
8577 dBrHXXRatio1 = BrHXXRatio - 1.0;
8581 dBrHXXRatio1 = BrHXXRatio - 1.0;
8585 dBrHXXRatio1 = BrHXXRatio - 1.0;
8589 dBrHXXRatio1 = BrHXXRatio - 1.0;
8592 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8596 if ((this->
getModel()).isModelLinearized()){
8597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8598 }
else if((this->
getModel()).isModelNPquadratic()){
8599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8601 return weight*(muProd)*(BrHXXRatio);
8614:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8617 throw std::runtime_error(
"STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8624 double weight = 1.0;
8628 /(0.10632 + 0.017974);
8629 double muProd1 = muProd -1.0;
8630 double muProd2 = 0.0;
8633 double BrHXXRatio = 1.0;
8634 double dBrHXXRatio1 = 0.0;
8635 double dBrHXXRatio2 = 0.0;
8638 weight = (0.10632 + 0.017974);
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8649 dBrHXXRatio1 = BrHXXRatio - 1.0;
8653 dBrHXXRatio1 = BrHXXRatio - 1.0;
8657 dBrHXXRatio1 = BrHXXRatio - 1.0;
8661 dBrHXXRatio1 = BrHXXRatio - 1.0;
8665 dBrHXXRatio1 = BrHXXRatio - 1.0;
8668 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8672 if ((this->
getModel()).isModelLinearized()){
8673 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8674 }
else if((this->
getModel()).isModelNPquadratic()){
8675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8677 return weight*(muProd)*(BrHXXRatio);
8688:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8691 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8698 double weight = 1.0;
8701 double muProd1 = muProd -1.0;
8702 double muProd2 = 0.0;
8705 double BrHXXRatio = 1.0;
8706 double dBrHXXRatio1 = 0.0;
8707 double dBrHXXRatio2 = 0.0;
8710 weight = (0.45825 );
8713 dBrHXXRatio1 = BrHXXRatio - 1.0;
8717 dBrHXXRatio1 = BrHXXRatio - 1.0;
8721 dBrHXXRatio1 = BrHXXRatio - 1.0;
8725 dBrHXXRatio1 = BrHXXRatio - 1.0;
8729 dBrHXXRatio1 = BrHXXRatio - 1.0;
8733 dBrHXXRatio1 = BrHXXRatio - 1.0;
8737 dBrHXXRatio1 = BrHXXRatio - 1.0;
8740 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8744 if ((this->
getModel()).isModelLinearized()){
8745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8746 }
else if((this->
getModel()).isModelNPquadratic()){
8747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8749 return weight*(muProd)*(BrHXXRatio);
8761:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8764 throw std::runtime_error(
"STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8771 double weight = 1.0;
8774 double muProd1 = muProd -1.0;
8775 double muProd2 = 0.0;
8778 double BrHXXRatio = 1.0;
8779 double dBrHXXRatio1 = 0.0;
8780 double dBrHXXRatio2 = 0.0;
8786 dBrHXXRatio1 = BrHXXRatio - 1.0;
8790 dBrHXXRatio1 = BrHXXRatio - 1.0;
8794 dBrHXXRatio1 = BrHXXRatio - 1.0;
8798 dBrHXXRatio1 = BrHXXRatio - 1.0;
8802 dBrHXXRatio1 = BrHXXRatio - 1.0;
8806 dBrHXXRatio1 = BrHXXRatio - 1.0;
8810 dBrHXXRatio1 = BrHXXRatio - 1.0;
8813 throw std::runtime_error(
"STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8817 if ((this->
getModel()).isModelLinearized()){
8818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8819 }
else if((this->
getModel()).isModelNPquadratic()){
8820 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8822 return weight*(muProd)*(BrHXXRatio);
8835:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8838 throw std::runtime_error(
"STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8845 double weight = 1.0;
8848 double muProd1 = muProd -1.0;
8849 double muProd2 = 0.0;
8852 double BrHXXRatio = 1.0;
8853 double dBrHXXRatio1 = 0.0;
8854 double dBrHXXRatio2 = 0.0;
8860 dBrHXXRatio1 = BrHXXRatio - 1.0;
8864 dBrHXXRatio1 = BrHXXRatio - 1.0;
8868 dBrHXXRatio1 = BrHXXRatio - 1.0;
8872 dBrHXXRatio1 = BrHXXRatio - 1.0;
8876 dBrHXXRatio1 = BrHXXRatio - 1.0;
8880 dBrHXXRatio1 = BrHXXRatio - 1.0;
8884 dBrHXXRatio1 = BrHXXRatio - 1.0;
8887 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8891 if ((this->
getModel()).isModelLinearized()){
8892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8893 }
else if((this->
getModel()).isModelNPquadratic()){
8894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8896 return weight*(muProd)*(BrHXXRatio);
8908:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8911 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8918 double weight = 1.0;
8921 double muProd1 = muProd -1.0;
8922 double muProd2 = 0.0;
8925 double BrHXXRatio = 1.0;
8926 double dBrHXXRatio1 = 0.0;
8927 double dBrHXXRatio2 = 0.0;
8933 dBrHXXRatio1 = BrHXXRatio - 1.0;
8937 dBrHXXRatio1 = BrHXXRatio - 1.0;
8941 dBrHXXRatio1 = BrHXXRatio - 1.0;
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8960 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8964 if ((this->
getModel()).isModelLinearized()){
8965 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8966 }
else if((this->
getModel()).isModelNPquadratic()){
8967 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8969 return weight*(muProd)*(BrHXXRatio);
8981:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8984 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8991 double weight = 1.0;
8994 double muProd1 = muProd -1.0;
8995 double muProd2 = 0.0;
8998 double BrHXXRatio = 1.0;
8999 double dBrHXXRatio1 = 0.0;
9000 double dBrHXXRatio2 = 0.0;
9006 dBrHXXRatio1 = BrHXXRatio - 1.0;
9010 dBrHXXRatio1 = BrHXXRatio - 1.0;
9014 dBrHXXRatio1 = BrHXXRatio - 1.0;
9018 dBrHXXRatio1 = BrHXXRatio - 1.0;
9022 dBrHXXRatio1 = BrHXXRatio - 1.0;
9026 dBrHXXRatio1 = BrHXXRatio - 1.0;
9030 dBrHXXRatio1 = BrHXXRatio - 1.0;
9033 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
9037 if ((this->
getModel()).isModelLinearized()){
9038 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9039 }
else if((this->
getModel()).isModelNPquadratic()){
9040 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9042 return weight*(muProd)*(BrHXXRatio);
9051:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9054 throw std::runtime_error(
"STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
9060 double BrHXXRatio = 1.0;
9070 throw std::runtime_error(
"STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
9073 if ((this->
getModel()).isModelLinearized()) {
9083:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9086 throw std::runtime_error(
"STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
9092 double BrHXXRatio = 1.0;
9102 throw std::runtime_error(
"STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
9105 if ((this->
getModel()).isModelLinearized()) {
9115:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9118 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
9124 double BrHXXRatio = 1.0;
9134 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
9137 if ((this->
getModel()).isModelLinearized()) {
9147:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9150 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
9156 double BrHXXRatio = 1.0;
9166 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
9169 if ((this->
getModel()).isModelLinearized()) {
9179:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9182 throw std::runtime_error(
"STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
9188 double BrHXXRatio = 1.0;
9198 throw std::runtime_error(
"STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
9201 if ((this->
getModel()).isModelLinearized()) {
9211:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9214 throw std::runtime_error(
"STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
9220 double BrHXXRatio = 1.0;
9230 throw std::runtime_error(
"STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
9233 if ((this->
getModel()).isModelLinearized()) {
9243:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9246 throw std::runtime_error(
"STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
9252 double BrHXXRatio = 1.0;
9262 throw std::runtime_error(
"STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
9265 if ((this->
getModel()).isModelLinearized()) {
9275:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9278 throw std::runtime_error(
"STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
9284 double BrHXXRatio = 1.0;
9294 throw std::runtime_error(
"STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
9297 if ((this->
getModel()).isModelLinearized()) {
9311:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9314 throw std::runtime_error(
"STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9321 double weight = 1.0;
9324 double muProd1 = muProd -1.0;
9325 double muProd2 = 0.0;
9328 double BrHXXRatio = 1.0;
9329 double dBrHXXRatio1 = 0.0;
9330 double dBrHXXRatio2 = 0.0;
9336 dBrHXXRatio1 = BrHXXRatio - 1.0;
9340 dBrHXXRatio1 = BrHXXRatio - 1.0;
9344 dBrHXXRatio1 = BrHXXRatio - 1.0;
9348 dBrHXXRatio1 = BrHXXRatio - 1.0;
9352 dBrHXXRatio1 = BrHXXRatio - 1.0;
9356 dBrHXXRatio1 = BrHXXRatio - 1.0;
9360 dBrHXXRatio1 = BrHXXRatio - 1.0;
9363 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9367 if ((this->
getModel()).isModelLinearized()){
9368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9369 }
else if((this->
getModel()).isModelNPquadratic()){
9370 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9372 return weight*(muProd)*(BrHXXRatio);
9386:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9389 throw std::runtime_error(
"STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9396 double weight = 1.0;
9398 double muProd1 = muProd -1.0;
9399 double muProd2 = 0.0;
9402 double BrHXXRatio = 1.0;
9403 double dBrHXXRatio1 = 0.0;
9404 double dBrHXXRatio2 = 0.0;
9410 dBrHXXRatio1 = BrHXXRatio - 1.0;
9414 dBrHXXRatio1 = BrHXXRatio - 1.0;
9418 dBrHXXRatio1 = BrHXXRatio - 1.0;
9422 dBrHXXRatio1 = BrHXXRatio - 1.0;
9426 dBrHXXRatio1 = BrHXXRatio - 1.0;
9430 dBrHXXRatio1 = BrHXXRatio - 1.0;
9434 dBrHXXRatio1 = BrHXXRatio - 1.0;
9437 throw std::runtime_error(
"STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9441 if ((this->
getModel()).isModelLinearized()){
9442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9443 }
else if((this->
getModel()).isModelNPquadratic()){
9444 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9446 return weight*(muProd)*(BrHXXRatio);
9453:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9456 throw std::runtime_error(
"STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9462 double BrHXXRatio = 1.0;
9472 throw std::runtime_error(
"STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9475 if ((this->
getModel()).isModelLinearized()) {
9486:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9489 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9496 double weight = 1.0;
9498 double muProd1 = muProd -1.0;
9499 double muProd2 = 0.0;
9502 double BrHXXRatio = 1.0;
9503 double dBrHXXRatio1 = 0.0;
9504 double dBrHXXRatio2 = 0.0;
9510 dBrHXXRatio1 = BrHXXRatio - 1.0;
9514 dBrHXXRatio1 = BrHXXRatio - 1.0;
9518 dBrHXXRatio1 = BrHXXRatio - 1.0;
9522 dBrHXXRatio1 = BrHXXRatio - 1.0;
9526 dBrHXXRatio1 = BrHXXRatio - 1.0;
9530 dBrHXXRatio1 = BrHXXRatio - 1.0;
9534 dBrHXXRatio1 = BrHXXRatio - 1.0;
9537 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9542 if ((this->
getModel()).isModelLinearized()){
9543 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9544 }
else if((this->
getModel()).isModelNPquadratic()){
9545 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9547 return weight*(muProd)*(BrHXXRatio);
9561:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9564 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9572 double weight = 1.0;
9574 double muProd1 = muProd -1.0;
9575 double muProd2 = 0.0;
9578 double BrHXXRatio = 1.0;
9579 double dBrHXXRatio1 = 0.0;
9580 double dBrHXXRatio2 = 0.0;
9586 dBrHXXRatio1 = BrHXXRatio - 1.0;
9590 dBrHXXRatio1 = BrHXXRatio - 1.0;
9594 dBrHXXRatio1 = BrHXXRatio - 1.0;
9598 dBrHXXRatio1 = BrHXXRatio - 1.0;
9602 dBrHXXRatio1 = BrHXXRatio - 1.0;
9606 dBrHXXRatio1 = BrHXXRatio - 1.0;
9610 dBrHXXRatio1 = BrHXXRatio - 1.0;
9613 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9617 if ((this->
getModel()).isModelLinearized()){
9618 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9619 }
else if((this->
getModel()).isModelNPquadratic()){
9620 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9622 return weight*(muProd)*(BrHXXRatio);
9636:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9639 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9647 double weight = 1.0;
9649 double muProd1 = muProd -1.0;
9650 double muProd2 = 0.0;
9653 double BrHXXRatio = 1.0;
9654 double dBrHXXRatio1 = 0.0;
9655 double dBrHXXRatio2 = 0.0;
9661 dBrHXXRatio1 = BrHXXRatio - 1.0;
9665 dBrHXXRatio1 = BrHXXRatio - 1.0;
9669 dBrHXXRatio1 = BrHXXRatio - 1.0;
9673 dBrHXXRatio1 = BrHXXRatio - 1.0;
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9685 dBrHXXRatio1 = BrHXXRatio - 1.0;
9688 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9692 if ((this->
getModel()).isModelLinearized()){
9693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9694 }
else if((this->
getModel()).isModelNPquadratic()){
9695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9697 return weight*(muProd)*(BrHXXRatio);
9707:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9710 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9720 double weight = 1.0;
9722 double muProd1 = muProd -1.0;
9723 double muProd2 = 0.0;
9726 double BrHXXRatio = 1.0;
9727 double dBrHXXRatio1 = 0.0;
9728 double dBrHXXRatio2 = 0.0;
9734 dBrHXXRatio1 = BrHXXRatio - 1.0;
9738 dBrHXXRatio1 = BrHXXRatio - 1.0;
9742 dBrHXXRatio1 = BrHXXRatio - 1.0;
9746 dBrHXXRatio1 = BrHXXRatio - 1.0;
9750 dBrHXXRatio1 = BrHXXRatio - 1.0;
9754 dBrHXXRatio1 = BrHXXRatio - 1.0;
9758 dBrHXXRatio1 = BrHXXRatio - 1.0;
9761 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9765 if ((this->
getModel()).isModelLinearized()){
9766 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9767 }
else if((this->
getModel()).isModelNPquadratic()){
9768 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9770 return weight*(muProd)*(BrHXXRatio);
9781:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9784 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9796 double weight = 1.0;
9798 double muProd1 = muProd -1.0;
9799 double muProd2 = 0.0;
9802 double BrHXXRatio = 1.0;
9803 double dBrHXXRatio1 = 0.0;
9804 double dBrHXXRatio2 = 0.0;
9810 dBrHXXRatio1 = BrHXXRatio - 1.0;
9814 dBrHXXRatio1 = BrHXXRatio - 1.0;
9818 dBrHXXRatio1 = BrHXXRatio - 1.0;
9822 dBrHXXRatio1 = BrHXXRatio - 1.0;
9826 dBrHXXRatio1 = BrHXXRatio - 1.0;
9830 dBrHXXRatio1 = BrHXXRatio - 1.0;
9834 dBrHXXRatio1 = BrHXXRatio - 1.0;
9837 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9841 if ((this->
getModel()).isModelLinearized()){
9842 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9843 }
else if((this->
getModel()).isModelNPquadratic()){
9844 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9846 return weight*(muProd)*(BrHXXRatio);
9867:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9870 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9880 double weight = 1.0;
9884 )/(0.175166+0.1647);
9885 double muProd1 = muProd -1.0;
9886 double muProd2 = 0.0;
9889 double BrHXXRatio = 1.0;
9890 double dBrHXXRatio1 = 0.0;
9891 double dBrHXXRatio2 = 0.0;
9897 dBrHXXRatio1 = BrHXXRatio - 1.0;
9901 dBrHXXRatio1 = BrHXXRatio - 1.0;
9905 dBrHXXRatio1 = BrHXXRatio - 1.0;
9909 dBrHXXRatio1 = BrHXXRatio - 1.0;
9913 dBrHXXRatio1 = BrHXXRatio - 1.0;
9917 dBrHXXRatio1 = BrHXXRatio - 1.0;
9921 dBrHXXRatio1 = BrHXXRatio - 1.0;
9924 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9928 if ((this->
getModel()).isModelLinearized()){
9929 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9930 }
else if((this->
getModel()).isModelNPquadratic()){
9931 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9933 return weight*(muProd)*(BrHXXRatio);
9950:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9953 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9960 double weight = 1.0;
9962 double muProd1 = muProd -1.0;
9963 double muProd2 = 0.0;
9966 double BrHXXRatio = 1.0;
9967 double dBrHXXRatio1 = 0.0;
9968 double dBrHXXRatio2 = 0.0;
9974 dBrHXXRatio1 = BrHXXRatio - 1.0;
9978 dBrHXXRatio1 = BrHXXRatio - 1.0;
9982 dBrHXXRatio1 = BrHXXRatio - 1.0;
9986 dBrHXXRatio1 = BrHXXRatio - 1.0;
9990 dBrHXXRatio1 = BrHXXRatio - 1.0;
9994 dBrHXXRatio1 = BrHXXRatio - 1.0;
9998 dBrHXXRatio1 = BrHXXRatio - 1.0;
10001 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10005 if ((this->
getModel()).isModelLinearized()){
10006 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10007 }
else if((this->
getModel()).isModelNPquadratic()){
10008 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10010 return weight*(muProd)*(BrHXXRatio);
10020:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10023 throw std::runtime_error(
"STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10030 double weight = 1.0;
10032 double muProd1 = muProd -1.0;
10033 double muProd2 = 0.0;
10036 double BrHXXRatio = 1.0;
10037 double dBrHXXRatio1 = 0.0;
10038 double dBrHXXRatio2 = 0.0;
10042 }
else if (
fstate == 1){
10044 dBrHXXRatio1 = BrHXXRatio - 1.0;
10045 dBrHXXRatio2 = 0.0;
10046 }
else if (
fstate == 2){
10048 dBrHXXRatio1 = BrHXXRatio - 1.0;
10049 dBrHXXRatio2 = 0.0;
10050 }
else if (
fstate == 3){
10052 dBrHXXRatio1 = BrHXXRatio - 1.0;
10053 dBrHXXRatio2 = 0.0;
10054 }
else if (
fstate == 4){
10056 dBrHXXRatio1 = BrHXXRatio - 1.0;
10057 dBrHXXRatio2 = 0.0;
10058 }
else if (
fstate == 5){
10060 dBrHXXRatio1 = BrHXXRatio - 1.0;
10061 dBrHXXRatio2 = 0.0;
10062 }
else if (
fstate == 6){
10064 dBrHXXRatio1 = BrHXXRatio - 1.0;
10065 dBrHXXRatio2 = 0.0;
10066 }
else if (
fstate == 7){
10068 dBrHXXRatio1 = BrHXXRatio - 1.0;
10069 dBrHXXRatio2 = 0.0;
10071 throw std::runtime_error(
"STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10075 if ((this->
getModel()).isModelLinearized()){
10076 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10077 }
else if((this->
getModel()).isModelNPquadratic()){
10078 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10080 return weight*(muProd)*(BrHXXRatio);
10090:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10093 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10100 double weight = 1.0;
10102 double muProd1 = muProd -1.0;
10103 double muProd2 = 0.0;
10106 double BrHXXRatio = 1.0;
10107 double dBrHXXRatio1 = 0.0;
10108 double dBrHXXRatio2 = 0.0;
10112 }
else if (
fstate == 1){
10114 dBrHXXRatio1 = BrHXXRatio - 1.0;
10115 dBrHXXRatio2 = 0.0;
10116 }
else if (
fstate == 2){
10118 dBrHXXRatio1 = BrHXXRatio - 1.0;
10119 dBrHXXRatio2 = 0.0;
10120 }
else if (
fstate == 3){
10122 dBrHXXRatio1 = BrHXXRatio - 1.0;
10123 dBrHXXRatio2 = 0.0;
10124 }
else if (
fstate == 4){
10126 dBrHXXRatio1 = BrHXXRatio - 1.0;
10127 dBrHXXRatio2 = 0.0;
10128 }
else if (
fstate == 5){
10130 dBrHXXRatio1 = BrHXXRatio - 1.0;
10131 dBrHXXRatio2 = 0.0;
10132 }
else if (
fstate == 6){
10134 dBrHXXRatio1 = BrHXXRatio - 1.0;
10135 dBrHXXRatio2 = 0.0;
10136 }
else if (
fstate == 7){
10138 dBrHXXRatio1 = BrHXXRatio - 1.0;
10139 dBrHXXRatio2 = 0.0;
10141 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10145 if ((this->
getModel()).isModelLinearized()){
10146 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10147 }
else if((this->
getModel()).isModelNPquadratic()){
10148 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10150 return weight*(muProd)*(BrHXXRatio);
10160:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10163 throw std::runtime_error(
"STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10170 double weight = 1.0;
10172 double muProd1 = muProd -1.0;
10173 double muProd2 = 0.0;
10176 double BrHXXRatio = 1.0;
10177 double dBrHXXRatio1 = 0.0;
10178 double dBrHXXRatio2 = 0.0;
10182 }
else if (
fstate == 1){
10184 dBrHXXRatio1 = BrHXXRatio - 1.0;
10185 dBrHXXRatio2 = 0.0;
10186 }
else if (
fstate == 2){
10188 dBrHXXRatio1 = BrHXXRatio - 1.0;
10189 dBrHXXRatio2 = 0.0;
10190 }
else if (
fstate == 3){
10192 dBrHXXRatio1 = BrHXXRatio - 1.0;
10193 dBrHXXRatio2 = 0.0;
10194 }
else if (
fstate == 4){
10196 dBrHXXRatio1 = BrHXXRatio - 1.0;
10197 dBrHXXRatio2 = 0.0;
10198 }
else if (
fstate == 5){
10200 dBrHXXRatio1 = BrHXXRatio - 1.0;
10201 dBrHXXRatio2 = 0.0;
10202 }
else if (
fstate == 6){
10204 dBrHXXRatio1 = BrHXXRatio - 1.0;
10205 dBrHXXRatio2 = 0.0;
10206 }
else if (
fstate == 7){
10208 dBrHXXRatio1 = BrHXXRatio - 1.0;
10209 dBrHXXRatio2 = 0.0;
10211 throw std::runtime_error(
"STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10215 if ((this->
getModel()).isModelLinearized()){
10216 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10217 }
else if((this->
getModel()).isModelNPquadratic()){
10218 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10220 return weight*(muProd)*(BrHXXRatio);
10229:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10232 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10239 double weight = 1.0;
10244 ) / (0.22408+0.21578);
10245 double muProd1 = muProd - 1.0;
10246 double muProd2 = 0.0;
10249 double BrHXXRatio = 1.0;
10250 double dBrHXXRatio1 = 0.0;
10251 double dBrHXXRatio2 = 0.0;
10254 weight = (0.22408+0.21578) ;
10255 }
else if (
fstate == 1){
10257 dBrHXXRatio1 = BrHXXRatio - 1.0;
10258 dBrHXXRatio2 = 0.0;
10259 }
else if (
fstate == 2){
10261 dBrHXXRatio1 = BrHXXRatio - 1.0;
10262 dBrHXXRatio2 = 0.0;
10263 }
else if (
fstate == 3){
10265 dBrHXXRatio1 = BrHXXRatio - 1.0;
10266 dBrHXXRatio2 = 0.0;
10267 }
else if (
fstate == 4){
10269 dBrHXXRatio1 = BrHXXRatio - 1.0;
10270 dBrHXXRatio2 = 0.0;
10271 }
else if (
fstate == 5){
10273 dBrHXXRatio1 = BrHXXRatio - 1.0;
10274 dBrHXXRatio2 = 0.0;
10275 }
else if (
fstate == 6){
10277 dBrHXXRatio1 = BrHXXRatio - 1.0;
10278 dBrHXXRatio2 = 0.0;
10279 }
else if (
fstate == 7){
10281 dBrHXXRatio1 = BrHXXRatio - 1.0;
10282 dBrHXXRatio2 = 0.0;
10284 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10288 if ((this->
getModel()).isModelLinearized()){
10289 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10290 }
else if((this->
getModel()).isModelNPquadratic()){
10291 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10293 return weight*(muProd)*(BrHXXRatio);
10305:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10308 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10315 double weight = 1.0;
10321 )/(0.25614+0.22408+0.21578);
10322 double muProd1 = (muProd-1.0);
10323 double muProd2 = 0.0;
10326 double BrHXXRatio = 1.0;
10327 double dBrHXXRatio1 = 0.0;
10328 double dBrHXXRatio2 = 0.0;
10331 weight = (0.25614+0.22408+0.21578);
10332 }
else if (
fstate == 1){
10334 dBrHXXRatio1 = BrHXXRatio - 1.0;
10335 dBrHXXRatio2 = 0.0;
10336 }
else if (
fstate == 2){
10338 dBrHXXRatio1 = BrHXXRatio - 1.0;
10339 dBrHXXRatio2 = 0.0;
10340 }
else if (
fstate == 3){
10342 dBrHXXRatio1 = BrHXXRatio - 1.0;
10343 dBrHXXRatio2 = 0.0;
10344 }
else if (
fstate == 4){
10346 dBrHXXRatio1 = BrHXXRatio - 1.0;
10347 dBrHXXRatio2 = 0.0;
10348 }
else if (
fstate == 5){
10350 dBrHXXRatio1 = BrHXXRatio - 1.0;
10351 dBrHXXRatio2 = 0.0;
10352 }
else if (
fstate == 6){
10354 dBrHXXRatio1 = BrHXXRatio - 1.0;
10355 dBrHXXRatio2 = 0.0;
10356 }
else if (
fstate == 7){
10358 dBrHXXRatio1 = BrHXXRatio - 1.0;
10359 dBrHXXRatio2 = 0.0;
10361 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10365 if ((this->
getModel()).isModelLinearized()){
10366 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10367 }
else if((this->
getModel()).isModelNPquadratic()){
10368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10370 return weight*(muProd)*(BrHXXRatio);
10383:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10386 throw std::runtime_error(
"STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10393 double weight = 1.0;
10395 double muProd1 = muProd -1.0;
10396 double muProd2 = 0.0;
10399 double BrHXXRatio = 1.0;
10400 double dBrHXXRatio1 = 0.0;
10401 double dBrHXXRatio2 = 0.0;
10405 }
else if (
fstate == 1){
10407 dBrHXXRatio1 = BrHXXRatio - 1.0;
10408 dBrHXXRatio2 = 0.0;
10409 }
else if (
fstate == 2){
10411 dBrHXXRatio1 = BrHXXRatio - 1.0;
10412 dBrHXXRatio2 = 0.0;
10413 }
else if (
fstate == 3){
10415 dBrHXXRatio1 = BrHXXRatio - 1.0;
10416 dBrHXXRatio2 = 0.0;
10417 }
else if (
fstate == 4){
10419 dBrHXXRatio1 = BrHXXRatio - 1.0;
10420 dBrHXXRatio2 = 0.0;
10422 throw std::runtime_error(
"STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10426 if ((this->
getModel()).isModelLinearized()){
10427 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10428 }
else if((this->
getModel()).isModelNPquadratic()){
10429 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10431 return weight*(muProd)*(BrHXXRatio);
10441:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10444 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10451 double weight = 1.0;
10453 double muProd1 = muProd -1.0;
10454 double muProd2 = 0.0;
10457 double BrHXXRatio = 1.0;
10458 double dBrHXXRatio1 = 0.0;
10459 double dBrHXXRatio2 = 0.0;
10463 }
else if (
fstate == 1){
10465 dBrHXXRatio1 = BrHXXRatio - 1.0;
10466 dBrHXXRatio2 = 0.0;
10467 }
else if (
fstate == 2){
10469 dBrHXXRatio1 = BrHXXRatio - 1.0;
10470 dBrHXXRatio2 = 0.0;
10471 }
else if (
fstate == 3){
10473 dBrHXXRatio1 = BrHXXRatio - 1.0;
10474 dBrHXXRatio2 = 0.0;
10475 }
else if (
fstate == 4){
10477 dBrHXXRatio1 = BrHXXRatio - 1.0;
10478 dBrHXXRatio2 = 0.0;
10480 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10484 if ((this->
getModel()).isModelLinearized()){
10485 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10486 }
else if((this->
getModel()).isModelNPquadratic()){
10487 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10489 return weight*(muProd)*(BrHXXRatio);
10498:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10501 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
10508 double weight = 1.0;
10518 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
10520 double muProd1 = muProd - 1.;
10521 double muProd2 = 0.0;
10524 double BrHXXRatio = 1.0;
10525 double dBrHXXRatio1 = 0.0;
10526 double dBrHXXRatio2 = 0.0;
10529 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315);
10530 }
else if (
fstate == 1){
10532 dBrHXXRatio1 = BrHXXRatio - 1.0;
10533 dBrHXXRatio2 = 0.0;
10534 }
else if (
fstate == 2){
10536 dBrHXXRatio1 = BrHXXRatio - 1.0;
10537 dBrHXXRatio2 = 0.0;
10538 }
else if (
fstate == 3){
10540 dBrHXXRatio1 = BrHXXRatio - 1.0;
10541 dBrHXXRatio2 = 0.0;
10542 }
else if (
fstate == 4){
10544 dBrHXXRatio1 = BrHXXRatio - 1.0;
10545 dBrHXXRatio2 = 0.0;
10546 }
else if (
fstate == 5){
10548 dBrHXXRatio1 = BrHXXRatio - 1.0;
10549 dBrHXXRatio2 = 0.0;
10551 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10558 if ((this->
getModel()).isModelLinearized()){
10560 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10561 }
else if((this->
getModel()).isModelNPquadratic()){
10563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10566 return weight*(muProd)*(BrHXXRatio);
10574:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10577 throw std::runtime_error(
"STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
10584 double weight = 1.0;
10586 double muProd1 = muProd -1.0;
10587 double muProd2 = 0.0;
10590 double BrHXXRatio = 1.0;
10591 double dBrHXXRatio1 = 0.0;
10592 double dBrHXXRatio2 = 0.0;
10596 }
else if (
fstate == 1){
10598 dBrHXXRatio1 = BrHXXRatio - 1.0;
10599 dBrHXXRatio2 = 0.0;
10600 }
else if (
fstate == 2){
10602 dBrHXXRatio1 = BrHXXRatio - 1.0;
10603 dBrHXXRatio2 = 0.0;
10604 }
else if (
fstate == 3){
10606 dBrHXXRatio1 = BrHXXRatio - 1.0;
10607 dBrHXXRatio2 = 0.0;
10608 }
else if (
fstate == 4){
10610 dBrHXXRatio1 = BrHXXRatio - 1.0;
10611 dBrHXXRatio2 = 0.0;
10612 }
else if (
fstate == 5){
10614 dBrHXXRatio1 = BrHXXRatio - 1.0;
10615 dBrHXXRatio2 = 0.0;
10617 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10621 if ((this->
getModel()).isModelLinearized()){
10622 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10623 }
else if((this->
getModel()).isModelNPquadratic()){
10624 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10626 return weight*(muProd)*(BrHXXRatio);
10634:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10637 throw std::runtime_error(
"STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10644 double weight = 1.0;
10646 double muProd1 = muProd -1.0;
10647 double muProd2 = 0.0;
10650 double BrHXXRatio = 1.0;
10651 double dBrHXXRatio1 = 0.0;
10652 double dBrHXXRatio2 = 0.0;
10656 }
else if (
fstate == 1){
10658 dBrHXXRatio1 = BrHXXRatio - 1.0;
10659 dBrHXXRatio2 = 0.0;
10660 }
else if (
fstate == 2){
10662 dBrHXXRatio1 = BrHXXRatio - 1.0;
10663 dBrHXXRatio2 = 0.0;
10664 }
else if (
fstate == 3){
10666 dBrHXXRatio1 = BrHXXRatio - 1.0;
10667 dBrHXXRatio2 = 0.0;
10668 }
else if (
fstate == 4){
10670 dBrHXXRatio1 = BrHXXRatio - 1.0;
10671 dBrHXXRatio2 = 0.0;
10672 }
else if (
fstate == 5){
10674 dBrHXXRatio1 = BrHXXRatio - 1.0;
10675 dBrHXXRatio2 = 0.0;
10677 throw std::runtime_error(
"STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10681 if ((this->
getModel()).isModelLinearized()){
10682 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10683 }
else if((this->
getModel()).isModelNPquadratic()){
10684 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10686 return weight*(muProd)*(BrHXXRatio);
10695:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10698 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10705 double weight = 1.0;
10708 double muProd2 = 0.0;
10711 double BrHXXRatio = 1.0;
10712 double dBrHXXRatio1 = 0.0;
10713 double dBrHXXRatio2 = 0.0;
10717 }
else if (
fstate == 1){
10719 dBrHXXRatio1 = BrHXXRatio - 1.0;
10720 dBrHXXRatio2 = 0.0;
10721 }
else if (
fstate == 2){
10723 dBrHXXRatio1 = BrHXXRatio - 1.0;
10724 dBrHXXRatio2 = 0.0;
10725 }
else if (
fstate == 3){
10727 dBrHXXRatio1 = BrHXXRatio - 1.0;
10728 dBrHXXRatio2 = 0.0;
10729 }
else if (
fstate == 4){
10731 dBrHXXRatio1 = BrHXXRatio - 1.0;
10732 dBrHXXRatio2 = 0.0;
10733 }
else if (
fstate == 5){
10735 dBrHXXRatio1 = BrHXXRatio - 1.0;
10736 dBrHXXRatio2 = 0.0;
10738 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10742 if ((this->
getModel()).isModelLinearized()){
10743 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10744 }
else if((this->
getModel()).isModelNPquadratic()){
10745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10747 return weight*(muProd)*(BrHXXRatio);
10761:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10764 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10770 double BrHXXRatio = 1.0;
10773 }
else if (
fstate == 2){
10775 }
else if (
fstate == 3){
10777 }
else if (
fstate == 4){
10780 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10783 if ((this->
getModel()).isModelLinearized()) {
10793:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10796 throw std::runtime_error(
"STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10804 double weight = 1.0;
10808 double muProd1 = (muProd -1.);
10809 double muProd2 = 0.0;
10812 double BrHXXRatio = 1.0;
10813 double dBrHXXRatio1 = 0.0;
10814 double dBrHXXRatio2 = 0.0;
10817 weight = (0.01127+0.00339) ;
10818 }
else if (
fstate == 1){
10820 dBrHXXRatio1 = BrHXXRatio - 1.0;
10821 dBrHXXRatio2 = 0.0;
10822 }
else if (
fstate == 2){
10824 dBrHXXRatio1 = BrHXXRatio - 1.0;
10825 dBrHXXRatio2 = 0.0;
10826 }
else if (
fstate == 3){
10828 dBrHXXRatio1 = BrHXXRatio - 1.0;
10829 dBrHXXRatio2 = 0.0;
10830 }
else if (
fstate == 4){
10832 dBrHXXRatio1 = BrHXXRatio - 1.0;
10833 dBrHXXRatio2 = 0.0;
10834 }
else if (
fstate == 5){
10836 dBrHXXRatio1 = BrHXXRatio - 1.0;
10837 dBrHXXRatio2 = 0.0;
10838 }
else if (
fstate == 6){
10840 dBrHXXRatio1 = BrHXXRatio - 1.0;
10841 dBrHXXRatio2 = 0.0;
10842 }
else if (
fstate == 7){
10844 dBrHXXRatio1 = BrHXXRatio - 1.0;
10845 dBrHXXRatio2 = 0.0;
10847 throw std::runtime_error(
"STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10851 if ((this->
getModel()).isModelLinearized()){
10852 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10853 }
else if((this->
getModel()).isModelNPquadratic()){
10854 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10856 return weight*(muProd)*(BrHXXRatio);
10866:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10869 throw std::runtime_error(
"STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10876 double weight = 1.0;
10883 double muProd2 = 0.0;
10886 double BrHXXRatio = 1.0;
10887 double dBrHXXRatio1 = 0.0;
10888 double dBrHXXRatio2 = 0.0;
10891 weight = (0.21509+0.13440) ;
10892 }
else if (
fstate == 1){
10894 dBrHXXRatio1 = BrHXXRatio - 1.0;
10895 dBrHXXRatio2 = 0.0;
10896 }
else if (
fstate == 2){
10898 dBrHXXRatio1 = BrHXXRatio - 1.0;
10899 dBrHXXRatio2 = 0.0;
10900 }
else if (
fstate == 3){
10902 dBrHXXRatio1 = BrHXXRatio - 1.0;
10903 dBrHXXRatio2 = 0.0;
10904 }
else if (
fstate == 4){
10906 dBrHXXRatio1 = BrHXXRatio - 1.0;
10907 dBrHXXRatio2 = 0.0;
10908 }
else if (
fstate == 5){
10910 dBrHXXRatio1 = BrHXXRatio - 1.0;
10911 dBrHXXRatio2 = 0.0;
10912 }
else if (
fstate == 6){
10914 dBrHXXRatio1 = BrHXXRatio - 1.0;
10915 dBrHXXRatio2 = 0.0;
10916 }
else if (
fstate == 7){
10918 dBrHXXRatio1 = BrHXXRatio - 1.0;
10919 dBrHXXRatio2 = 0.0;
10921 throw std::runtime_error(
"STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10925 if ((this->
getModel()).isModelLinearized()){
10926 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10927 }
else if((this->
getModel()).isModelNPquadratic()){
10928 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10930 return weight*(muProd)*(BrHXXRatio);
10940:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10943 throw std::runtime_error(
"STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10950 double weight = 1.0;
10959 double muProd2 = 0.0;
10962 double BrHXXRatio = 1.0;
10963 double dBrHXXRatio1 = 0.0;
10964 double dBrHXXRatio2 = 0.0;
10967 weight = (0.04117+0.01004+0.00214) ;
10968 }
else if (
fstate == 1){
10970 dBrHXXRatio1 = BrHXXRatio - 1.0;
10971 dBrHXXRatio2 = 0.0;
10972 }
else if (
fstate == 2){
10974 dBrHXXRatio1 = BrHXXRatio - 1.0;
10975 dBrHXXRatio2 = 0.0;
10976 }
else if (
fstate == 3){
10978 dBrHXXRatio1 = BrHXXRatio - 1.0;
10979 dBrHXXRatio2 = 0.0;
10980 }
else if (
fstate == 4){
10982 dBrHXXRatio1 = BrHXXRatio - 1.0;
10983 dBrHXXRatio2 = 0.0;
10984 }
else if (
fstate == 5){
10986 dBrHXXRatio1 = BrHXXRatio - 1.0;
10987 dBrHXXRatio2 = 0.0;
10988 }
else if (
fstate == 6){
10990 dBrHXXRatio1 = BrHXXRatio - 1.0;
10991 dBrHXXRatio2 = 0.0;
10992 }
else if (
fstate == 7){
10994 dBrHXXRatio1 = BrHXXRatio - 1.0;
10995 dBrHXXRatio2 = 0.0;
10997 throw std::runtime_error(
"STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
11001 if ((this->
getModel()).isModelLinearized()){
11002 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11003 }
else if((this->
getModel()).isModelNPquadratic()){
11004 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11006 return weight*(muProd)*(BrHXXRatio);
11016:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11019 throw std::runtime_error(
"STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
11026 double weight = 1.0;
11029 double muProd2 = 0.0;
11032 double BrHXXRatio = 1.0;
11033 double dBrHXXRatio1 = 0.0;
11034 double dBrHXXRatio2 = 0.0;
11038 }
else if (
fstate == 1){
11040 dBrHXXRatio1 = BrHXXRatio - 1.0;
11041 dBrHXXRatio2 = 0.0;
11042 }
else if (
fstate == 2){
11044 dBrHXXRatio1 = BrHXXRatio - 1.0;
11045 dBrHXXRatio2 = 0.0;
11046 }
else if (
fstate == 3){
11048 dBrHXXRatio1 = BrHXXRatio - 1.0;
11049 dBrHXXRatio2 = 0.0;
11050 }
else if (
fstate == 4){
11052 dBrHXXRatio1 = BrHXXRatio - 1.0;
11053 dBrHXXRatio2 = 0.0;
11055 throw std::runtime_error(
"STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
11059 if ((this->
getModel()).isModelLinearized()){
11060 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11061 }
else if((this->
getModel()).isModelNPquadratic()){
11062 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11064 return weight*(muProd)*(BrHXXRatio);
11074:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11077 throw std::runtime_error(
"STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
11084 double weight = 1.0;
11086 double muProd1 = muProd-1.0 ;
11087 double muProd2 = 0.0;
11090 double BrHXXRatio = 1.0;
11091 double dBrHXXRatio1 = 0.0;
11092 double dBrHXXRatio2 = 0.0;
11096 }
else if (
fstate == 1){
11098 dBrHXXRatio1 = BrHXXRatio - 1.0;
11099 dBrHXXRatio2 = 0.0;
11100 }
else if (
fstate == 2){
11102 dBrHXXRatio1 = BrHXXRatio - 1.0;
11103 dBrHXXRatio2 = 0.0;
11104 }
else if (
fstate == 3){
11106 dBrHXXRatio1 = BrHXXRatio - 1.0;
11107 dBrHXXRatio2 = 0.0;
11108 }
else if (
fstate == 4){
11110 dBrHXXRatio1 = BrHXXRatio - 1.0;
11111 dBrHXXRatio2 = 0.0;
11113 throw std::runtime_error(
"STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
11117 if ((this->
getModel()).isModelLinearized()){
11118 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11119 }
else if((this->
getModel()).isModelNPquadratic()){
11120 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11122 return weight*(muProd)*(BrHXXRatio);
11132:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11135 throw std::runtime_error(
"STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
11141 double BrHXXRatio = 1.0;
11144 }
else if (
fstate == 2){
11146 }
else if (
fstate == 3){
11148 }
else if (
fstate == 4){
11151 throw std::runtime_error(
"STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
11154 if ((this->
getModel()).isModelLinearized()) {
11165:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11168 throw std::runtime_error(
"STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
11175 double weight = 1.0;
11177 double muProd1 = muProd -1.0;
11178 double muProd2 = 0.0;
11181 double BrHXXRatio = 1.0;
11182 double dBrHXXRatio1 = 0.0;
11183 double dBrHXXRatio2 = 0.0;
11187 }
else if (
fstate == 1){
11189 dBrHXXRatio1 = BrHXXRatio - 1.0;
11190 dBrHXXRatio2 = 0.0;
11191 }
else if (
fstate == 2){
11193 dBrHXXRatio1 = BrHXXRatio - 1.0;
11194 dBrHXXRatio2 = 0.0;
11195 }
else if (
fstate == 3){
11197 dBrHXXRatio1 = BrHXXRatio - 1.0;
11198 dBrHXXRatio2 = 0.0;
11199 }
else if (
fstate == 4){
11201 dBrHXXRatio1 = BrHXXRatio - 1.0;
11202 dBrHXXRatio2 = 0.0;
11204 throw std::runtime_error(
"STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
11208 if ((this->
getModel()).isModelLinearized()){
11209 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11210 }
else if((this->
getModel()).isModelNPquadratic()){
11211 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11213 return weight*(muProd)*(BrHXXRatio);
11223:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11226 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
11233 double weight = 1.0;
11235 double muProd1 = muProd -1.0;
11236 double muProd2 = 0.0;
11239 double BrHXXRatio = 1.0;
11240 double dBrHXXRatio1 = 0.0;
11241 double dBrHXXRatio2 = 0.0;
11245 }
else if (
fstate == 1){
11247 dBrHXXRatio1 = BrHXXRatio - 1.0;
11248 dBrHXXRatio2 = 0.0;
11249 }
else if (
fstate == 2){
11251 dBrHXXRatio1 = BrHXXRatio - 1.0;
11252 dBrHXXRatio2 = 0.0;
11253 }
else if (
fstate == 3){
11255 dBrHXXRatio1 = BrHXXRatio - 1.0;
11256 dBrHXXRatio2 = 0.0;
11257 }
else if (
fstate == 4){
11259 dBrHXXRatio1 = BrHXXRatio - 1.0;
11260 dBrHXXRatio2 = 0.0;
11262 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11266 if ((this->
getModel()).isModelLinearized()){
11267 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11268 }
else if((this->
getModel()).isModelNPquadratic()){
11269 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11271 return weight*(muProd)*(BrHXXRatio);
11279:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11282 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
11290 double weight = 1.0;
11292 double muProd1 = muProd -1.0;
11293 double muProd2 = 0.0;
11296 double BrHXXRatio = 1.0;
11297 double dBrHXXRatio1 = 0.0;
11298 double dBrHXXRatio2 = 0.0;
11301 weight = (0.0168) ;
11302 }
else if (
fstate == 1){
11304 dBrHXXRatio1 = BrHXXRatio - 1.0;
11305 dBrHXXRatio2 = 0.0;
11306 }
else if (
fstate == 2){
11308 dBrHXXRatio1 = BrHXXRatio - 1.0;
11309 dBrHXXRatio2 = 0.0;
11310 }
else if (
fstate == 3){
11312 dBrHXXRatio1 = BrHXXRatio - 1.0;
11313 dBrHXXRatio2 = 0.0;
11314 }
else if (
fstate == 4){
11316 dBrHXXRatio1 = BrHXXRatio - 1.0;
11317 dBrHXXRatio2 = 0.0;
11319 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11323 if ((this->
getModel()).isModelLinearized()){
11324 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11325 }
else if((this->
getModel()).isModelNPquadratic()){
11326 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11328 return weight*(muProd)*(BrHXXRatio);
11340:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11343 throw std::runtime_error(
"STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
11349 double BrHXXRatio = 1.0;
11352 }
else if (
fstate == 2){
11354 }
else if (
fstate == 3){
11356 }
else if (
fstate == 4){
11359 throw std::runtime_error(
"STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
11362 if ((this->
getModel()).isModelLinearized()) {
11374:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11377 throw std::runtime_error(
"STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
11384 double weight = 1.0;
11386 double muProd1 = muProd -1.0;
11387 double muProd2 = 0.0;
11390 double BrHXXRatio = 1.0;
11391 double dBrHXXRatio1 = 0.0;
11392 double dBrHXXRatio2 = 0.0;
11396 }
else if (
fstate == 1){
11398 dBrHXXRatio1 = BrHXXRatio - 1.0;
11399 dBrHXXRatio2 = 0.0;
11400 }
else if (
fstate == 2){
11402 dBrHXXRatio1 = BrHXXRatio - 1.0;
11403 dBrHXXRatio2 = 0.0;
11404 }
else if (
fstate == 3){
11406 dBrHXXRatio1 = BrHXXRatio - 1.0;
11407 dBrHXXRatio2 = 0.0;
11408 }
else if (
fstate == 4){
11410 dBrHXXRatio1 = BrHXXRatio - 1.0;
11411 dBrHXXRatio2 = 0.0;
11412 }
else if (
fstate == 5){
11414 dBrHXXRatio1 = BrHXXRatio - 1.0;
11415 dBrHXXRatio2 = 0.0;
11416 }
else if (
fstate == 6){
11418 dBrHXXRatio1 = BrHXXRatio - 1.0;
11419 dBrHXXRatio2 = 0.0;
11420 }
else if (
fstate == 7){
11422 dBrHXXRatio1 = BrHXXRatio - 1.0;
11423 dBrHXXRatio2 = 0.0;
11425 throw std::runtime_error(
"STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
11429 if ((this->
getModel()).isModelLinearized()){
11430 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11431 }
else if((this->
getModel()).isModelNPquadratic()){
11432 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11434 return weight*(muProd)*(BrHXXRatio);
11443:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11446 throw std::runtime_error(
"STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
11453 double weight = 1.0;
11455 double muProd1 = muProd -1.0;
11456 double muProd2 = 0.0;
11459 double BrHXXRatio = 1.0;
11460 double dBrHXXRatio1 = 0.0;
11461 double dBrHXXRatio2 = 0.0;
11465 }
else if (
fstate == 1){
11467 dBrHXXRatio1 = BrHXXRatio - 1.0;
11468 dBrHXXRatio2 = 0.0;
11469 }
else if (
fstate == 2){
11471 dBrHXXRatio1 = BrHXXRatio - 1.0;
11472 dBrHXXRatio2 = 0.0;
11473 }
else if (
fstate == 3){
11475 dBrHXXRatio1 = BrHXXRatio - 1.0;
11476 dBrHXXRatio2 = 0.0;
11477 }
else if (
fstate == 4){
11479 dBrHXXRatio1 = BrHXXRatio - 1.0;
11480 dBrHXXRatio2 = 0.0;
11481 }
else if (
fstate == 5){
11483 dBrHXXRatio1 = BrHXXRatio - 1.0;
11484 dBrHXXRatio2 = 0.0;
11485 }
else if (
fstate == 6){
11487 dBrHXXRatio1 = BrHXXRatio - 1.0;
11488 dBrHXXRatio2 = 0.0;
11489 }
else if (
fstate == 7){
11491 dBrHXXRatio1 = BrHXXRatio - 1.0;
11492 dBrHXXRatio2 = 0.0;
11494 throw std::runtime_error(
"STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
11498 if ((this->
getModel()).isModelLinearized()){
11499 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11500 }
else if((this->
getModel()).isModelNPquadratic()){
11501 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11503 return weight*(muProd)*(BrHXXRatio);
11512:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11515 throw std::runtime_error(
"STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
11522 double weight = 1.0;
11524 double muProd1 = muProd -1.0;
11525 double muProd2 = 0.0;
11528 double BrHXXRatio = 1.0;
11529 double dBrHXXRatio1 = 0.0;
11530 double dBrHXXRatio2 = 0.0;
11534 }
else if (
fstate == 1){
11536 dBrHXXRatio1 = BrHXXRatio - 1.0;
11537 dBrHXXRatio2 = 0.0;
11538 }
else if (
fstate == 2){
11540 dBrHXXRatio1 = BrHXXRatio - 1.0;
11541 dBrHXXRatio2 = 0.0;
11542 }
else if (
fstate == 3){
11544 dBrHXXRatio1 = BrHXXRatio - 1.0;
11545 dBrHXXRatio2 = 0.0;
11546 }
else if (
fstate == 4){
11548 dBrHXXRatio1 = BrHXXRatio - 1.0;
11549 dBrHXXRatio2 = 0.0;
11550 }
else if (
fstate == 5){
11552 dBrHXXRatio1 = BrHXXRatio - 1.0;
11553 dBrHXXRatio2 = 0.0;
11554 }
else if (
fstate == 6){
11556 dBrHXXRatio1 = BrHXXRatio - 1.0;
11557 dBrHXXRatio2 = 0.0;
11558 }
else if (
fstate == 7){
11560 dBrHXXRatio1 = BrHXXRatio - 1.0;
11561 dBrHXXRatio2 = 0.0;
11563 throw std::runtime_error(
"STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
11567 if ((this->
getModel()).isModelLinearized()){
11568 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11569 }
else if((this->
getModel()).isModelNPquadratic()){
11570 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11572 return weight*(muProd)*(BrHXXRatio);
11582:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11585 throw std::runtime_error(
"STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
11592 double weight = 1.0;
11599 double muProd1 = muProd-1.0;
11600 double muProd2 = 0.0;
11603 double BrHXXRatio = 1.0;
11604 double dBrHXXRatio1 = 0.0;
11605 double dBrHXXRatio2 = 0.0;
11607 weight = (0.0147+0.01683+0.00715+0.00126);
11608 }
else if (
fstate == 1){
11610 dBrHXXRatio1 = BrHXXRatio - 1.0;
11611 dBrHXXRatio2 = 0.0;
11612 }
else if (
fstate == 2){
11614 dBrHXXRatio1 = BrHXXRatio - 1.0;
11615 dBrHXXRatio2 = 0.0;
11616 }
else if (
fstate == 3){
11618 dBrHXXRatio1 = BrHXXRatio - 1.0;
11619 dBrHXXRatio2 = 0.0;
11620 }
else if (
fstate == 4){
11622 dBrHXXRatio1 = BrHXXRatio - 1.0;
11623 dBrHXXRatio2 = 0.0;
11624 }
else if (
fstate == 5){
11626 dBrHXXRatio1 = BrHXXRatio - 1.0;
11627 dBrHXXRatio2 = 0.0;
11628 }
else if (
fstate == 6){
11630 dBrHXXRatio1 = BrHXXRatio - 1.0;
11631 dBrHXXRatio2 = 0.0;
11632 }
else if (
fstate == 7){
11634 dBrHXXRatio1 = BrHXXRatio - 1.0;
11635 dBrHXXRatio2 = 0.0;
11637 throw std::runtime_error(
"STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
11641 if ((this->
getModel()).isModelLinearized()){
11642 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11643 }
else if((this->
getModel()).isModelNPquadratic()){
11644 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11646 return weight*(muProd)*(BrHXXRatio);
11661:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11664 throw std::runtime_error(
"STXS12_qqHll called with a class whose parent is not NPbase");
11671 double weight = 1.0;
11679 )/(0.19845+0.0147+0.01683+0.00715+0.00126);
11680 double muProd1 = muProd - 1.0;
11681 double muProd2 = 0.0;
11684 double BrHXXRatio = 1.0;
11685 double dBrHXXRatio1 = 0.0;
11686 double dBrHXXRatio2 = 0.0;
11688 weight = (0.19845+0.0147+0.01683+0.00715+0.00126);
11689 }
else if (
fstate == 1){
11691 dBrHXXRatio1 = BrHXXRatio - 1.0;
11692 dBrHXXRatio2 = 0.0;
11693 }
else if (
fstate == 2){
11695 dBrHXXRatio1 = BrHXXRatio - 1.0;
11696 dBrHXXRatio2 = 0.0;
11697 }
else if (
fstate == 3){
11699 dBrHXXRatio1 = BrHXXRatio - 1.0;
11700 dBrHXXRatio2 = 0.0;
11701 }
else if (
fstate == 4){
11703 dBrHXXRatio1 = BrHXXRatio - 1.0;
11704 dBrHXXRatio2 = 0.0;
11705 }
else if (
fstate == 5){
11707 dBrHXXRatio1 = BrHXXRatio - 1.0;
11708 dBrHXXRatio2 = 0.0;
11709 }
else if (
fstate == 6){
11711 dBrHXXRatio1 = BrHXXRatio - 1.0;
11712 dBrHXXRatio2 = 0.0;
11713 }
else if (
fstate == 7){
11715 dBrHXXRatio1 = BrHXXRatio - 1.0;
11716 dBrHXXRatio2 = 0.0;
11718 throw std::runtime_error(
"STXS12_qqHll called with invalid argument for final state in fstate_i");
11722 if ((this->
getModel()).isModelLinearized()){
11723 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11724 }
else if((this->
getModel()).isModelNPquadratic()){
11725 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11727 return weight*(muProd)*(BrHXXRatio);
11740:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11743 throw std::runtime_error(
"STXS12_VHlep called with a class whose parent is not NPbase");
11750 double weight = 1.0;
11763 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11764 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11766 double muProd1 = muProd - 1.0;
11767 double muProd2 = 0.0;
11770 double BrHXXRatio = 1.0;
11771 double dBrHXXRatio1 = 0.0;
11772 double dBrHXXRatio2 = 0.0;
11774 weight = (0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11775 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11776 }
else if (
fstate == 1){
11778 dBrHXXRatio1 = BrHXXRatio - 1.0;
11779 dBrHXXRatio2 = 0.0;
11780 }
else if (
fstate == 2){
11782 dBrHXXRatio1 = BrHXXRatio - 1.0;
11783 dBrHXXRatio2 = 0.0;
11784 }
else if (
fstate == 3){
11786 dBrHXXRatio1 = BrHXXRatio - 1.0;
11787 dBrHXXRatio2 = 0.0;
11788 }
else if (
fstate == 4){
11790 dBrHXXRatio1 = BrHXXRatio - 1.0;
11791 dBrHXXRatio2 = 0.0;
11792 }
else if (
fstate == 5){
11794 dBrHXXRatio1 = BrHXXRatio - 1.0;
11795 dBrHXXRatio2 = 0.0;
11796 }
else if (
fstate == 6){
11798 dBrHXXRatio1 = BrHXXRatio - 1.0;
11799 dBrHXXRatio2 = 0.0;
11800 }
else if (
fstate == 7){
11802 dBrHXXRatio1 = BrHXXRatio - 1.0;
11803 dBrHXXRatio2 = 0.0;
11805 throw std::runtime_error(
"STXS12_VHlep called with invalid argument for final state in fstate_i");
11809 if ((this->
getModel()).isModelLinearized()){
11810 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11811 }
else if((this->
getModel()).isModelNPquadratic()){
11812 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11814 return weight*(muProd)*(BrHXXRatio);
11829:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11832 throw std::runtime_error(
"STXS12_VHlep_pTV0_150 called with a class whose parent is not NPbase");
11839 double weight = 1.0;
11846 /(0.71256 + 0.06739 + 0.07934);
11847 double muProd1 = muProd - 1.0;
11848 double muProd2 = 0.0;
11851 double BrHXXRatio = 1.0;
11852 double dBrHXXRatio1 = 0.0;
11853 double dBrHXXRatio2 = 0.0;
11856 }
else if (
fstate == 1){
11858 dBrHXXRatio1 = BrHXXRatio - 1.0;
11859 dBrHXXRatio2 = 0.0;
11860 }
else if (
fstate == 2){
11862 dBrHXXRatio1 = BrHXXRatio - 1.0;
11863 dBrHXXRatio2 = 0.0;
11864 }
else if (
fstate == 3){
11866 dBrHXXRatio1 = BrHXXRatio - 1.0;
11867 dBrHXXRatio2 = 0.0;
11868 }
else if (
fstate == 4){
11870 dBrHXXRatio1 = BrHXXRatio - 1.0;
11871 dBrHXXRatio2 = 0.0;
11872 }
else if (
fstate == 5){
11874 dBrHXXRatio1 = BrHXXRatio - 1.0;
11875 dBrHXXRatio2 = 0.0;
11876 }
else if (
fstate == 6){
11878 dBrHXXRatio1 = BrHXXRatio - 1.0;
11879 dBrHXXRatio2 = 0.0;
11880 }
else if (
fstate == 7){
11882 dBrHXXRatio1 = BrHXXRatio - 1.0;
11883 dBrHXXRatio2 = 0.0;
11885 throw std::runtime_error(
"STXS12_VHlep_pTV0_150 called with invalid argument for final state in fstate_i");
11889 if ((this->
getModel()).isModelLinearized()){
11890 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11891 }
else if((this->
getModel()).isModelNPquadratic()){
11892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11894 return weight*(muProd)*(BrHXXRatio);
11908:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11911 throw std::runtime_error(
"STXS12_VHlep_pTV150_Inf called with a class whose parent is not NPbase");
11918 double weight = 1.0;
11928 /(0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11929 double muProd1 = (muProd - 1.0);
11930 double muProd2 = 0.0;
11933 double BrHXXRatio = 1.0;
11934 double dBrHXXRatio1 = 0.0;
11935 double dBrHXXRatio2 = 0.0;
11937 weight = (0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11938 }
else if (
fstate == 1){
11940 dBrHXXRatio1 = BrHXXRatio - 1.0;
11941 dBrHXXRatio2 = 0.0;
11942 }
else if (
fstate == 2){
11944 dBrHXXRatio1 = BrHXXRatio - 1.0;
11945 dBrHXXRatio2 = 0.0;
11946 }
else if (
fstate == 3){
11948 dBrHXXRatio1 = BrHXXRatio - 1.0;
11949 dBrHXXRatio2 = 0.0;
11950 }
else if (
fstate == 4){
11952 dBrHXXRatio1 = BrHXXRatio - 1.0;
11953 dBrHXXRatio2 = 0.0;
11954 }
else if (
fstate == 5){
11956 dBrHXXRatio1 = BrHXXRatio - 1.0;
11957 dBrHXXRatio2 = 0.0;
11958 }
else if (
fstate == 6){
11960 dBrHXXRatio1 = BrHXXRatio - 1.0;
11961 dBrHXXRatio2 = 0.0;
11962 }
else if (
fstate == 7){
11964 dBrHXXRatio1 = BrHXXRatio - 1.0;
11965 dBrHXXRatio2 = 0.0;
11967 throw std::runtime_error(
"STXS12_VHlep_pTV150_Inf called with invalid argument for final state in fstate_i");
11971 if ((this->
getModel()).isModelLinearized()){
11972 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11973 }
else if((this->
getModel()).isModelNPquadratic()){
11974 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11976 return weight*(muProd)*(BrHXXRatio);
11991:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11994 throw std::runtime_error(
"STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
12001 double weight = 1.0;
12003 double muProd1 = muProd -1.0;
12004 double muProd2 = 0.0;
12007 double BrHXXRatio = 1.0;
12008 double dBrHXXRatio1 = 0.0;
12009 double dBrHXXRatio2 = 0.0;
12013 }
else if (
fstate == 1){
12015 dBrHXXRatio1 = BrHXXRatio - 1.0;
12016 dBrHXXRatio2 = 0.0;
12017 }
else if (
fstate == 2){
12019 dBrHXXRatio1 = BrHXXRatio - 1.0;
12020 dBrHXXRatio2 = 0.0;
12021 }
else if (
fstate == 3){
12023 dBrHXXRatio1 = BrHXXRatio - 1.0;
12024 dBrHXXRatio2 = 0.0;
12025 }
else if (
fstate == 4){
12027 dBrHXXRatio1 = BrHXXRatio - 1.0;
12028 dBrHXXRatio2 = 0.0;
12030 throw std::runtime_error(
"STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
12034 if ((this->
getModel()).isModelLinearized()){
12035 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12036 }
else if((this->
getModel()).isModelNPquadratic()){
12037 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12039 return weight*(muProd)*(BrHXXRatio);
12049:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12052 throw std::runtime_error(
"STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
12059 double weight = 1.0;
12061 double muProd1 = muProd -1.0;
12062 double muProd2 = 0.0;
12065 double BrHXXRatio = 1.0;
12066 double dBrHXXRatio1 = 0.0;
12067 double dBrHXXRatio2 = 0.0;
12071 }
else if (
fstate == 1){
12073 dBrHXXRatio1 = BrHXXRatio - 1.0;
12074 dBrHXXRatio2 = 0.0;
12075 }
else if (
fstate == 2){
12077 dBrHXXRatio1 = BrHXXRatio - 1.0;
12078 dBrHXXRatio2 = 0.0;
12079 }
else if (
fstate == 3){
12081 dBrHXXRatio1 = BrHXXRatio - 1.0;
12082 dBrHXXRatio2 = 0.0;
12083 }
else if (
fstate == 4){
12085 dBrHXXRatio1 = BrHXXRatio - 1.0;
12086 dBrHXXRatio2 = 0.0;
12088 throw std::runtime_error(
"STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
12092 if ((this->
getModel()).isModelLinearized()){
12093 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12094 }
else if((this->
getModel()).isModelNPquadratic()){
12095 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12097 return weight*(muProd)*(BrHXXRatio);
12106:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12109 throw std::runtime_error(
"STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
12116 double weight = 1.0;
12123 double muProd2 = 0.0;
12126 double BrHXXRatio = 1.0;
12127 double dBrHXXRatio1 = 0.0;
12128 double dBrHXXRatio2 = 0.0;
12132 }
else if (
fstate == 1){
12134 dBrHXXRatio1 = BrHXXRatio - 1.0;
12135 dBrHXXRatio2 = 0.0;
12136 }
else if (
fstate == 2){
12138 dBrHXXRatio1 = BrHXXRatio - 1.0;
12139 dBrHXXRatio2 = 0.0;
12140 }
else if (
fstate == 3){
12142 dBrHXXRatio1 = BrHXXRatio - 1.0;
12143 dBrHXXRatio2 = 0.0;
12144 }
else if (
fstate == 4){
12146 dBrHXXRatio1 = BrHXXRatio - 1.0;
12147 dBrHXXRatio2 = 0.0;
12149 throw std::runtime_error(
"STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
12153 if ((this->
getModel()).isModelLinearized()){
12154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12155 }
else if((this->
getModel()).isModelNPquadratic()){
12156 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12158 return weight*(muProd)*(BrHXXRatio);
12167:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12170 throw std::runtime_error(
"STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
12177 double weight = 1.0;
12179 double muProd1 = muProd -1.0;
12180 double muProd2 = 0.0;
12183 double BrHXXRatio = 1.0;
12184 double dBrHXXRatio1 = 0.0;
12185 double dBrHXXRatio2 = 0.0;
12189 }
else if (
fstate == 1){
12191 dBrHXXRatio1 = BrHXXRatio - 1.0;
12192 dBrHXXRatio2 = 0.0;
12193 }
else if (
fstate == 2){
12195 dBrHXXRatio1 = BrHXXRatio - 1.0;
12196 dBrHXXRatio2 = 0.0;
12197 }
else if (
fstate == 3){
12199 dBrHXXRatio1 = BrHXXRatio - 1.0;
12200 dBrHXXRatio2 = 0.0;
12201 }
else if (
fstate == 4){
12203 dBrHXXRatio1 = BrHXXRatio - 1.0;
12204 dBrHXXRatio2 = 0.0;
12206 throw std::runtime_error(
"STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
12210 if ((this->
getModel()).isModelLinearized()){
12211 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12212 }
else if((this->
getModel()).isModelNPquadratic()){
12213 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12215 return weight*(muProd)*(BrHXXRatio);
12224:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12227 throw std::runtime_error(
"STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
12234 double weight = 1.0;
12236 double muProd1 = muProd -1.0;
12237 double muProd2 = 0.0;
12240 double BrHXXRatio = 1.0;
12241 double dBrHXXRatio1 = 0.0;
12242 double dBrHXXRatio2 = 0.0;
12246 }
else if (
fstate == 1){
12248 dBrHXXRatio1 = BrHXXRatio - 1.0;
12249 dBrHXXRatio2 = 0.0;
12250 }
else if (
fstate == 2){
12252 dBrHXXRatio1 = BrHXXRatio - 1.0;
12253 dBrHXXRatio2 = 0.0;
12254 }
else if (
fstate == 3){
12256 dBrHXXRatio1 = BrHXXRatio - 1.0;
12257 dBrHXXRatio2 = 0.0;
12258 }
else if (
fstate == 4){
12260 dBrHXXRatio1 = BrHXXRatio - 1.0;
12261 dBrHXXRatio2 = 0.0;
12263 throw std::runtime_error(
"STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
12267 if ((this->
getModel()).isModelLinearized()){
12268 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12269 }
else if((this->
getModel()).isModelNPquadratic()){
12270 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12272 return weight*(muProd)*(BrHXXRatio);
12280:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12283 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
12291 double weight = 1.0;
12295 )/(0.01903+0.00538);
12296 double muProd1 = muProd -1.0;
12297 double muProd2 = 0.0;
12300 double BrHXXRatio = 1.0;
12301 double dBrHXXRatio1 = 0.0;
12302 double dBrHXXRatio2 = 0.0;
12305 weight = (0.01903+0.00538);
12306 }
else if (
fstate == 1){
12308 dBrHXXRatio1 = BrHXXRatio - 1.0;
12309 dBrHXXRatio2 = 0.0;
12310 }
else if (
fstate == 2){
12312 dBrHXXRatio1 = BrHXXRatio - 1.0;
12313 dBrHXXRatio2 = 0.0;
12314 }
else if (
fstate == 3){
12316 dBrHXXRatio1 = BrHXXRatio - 1.0;
12317 dBrHXXRatio2 = 0.0;
12318 }
else if (
fstate == 4){
12320 dBrHXXRatio1 = BrHXXRatio - 1.0;
12321 dBrHXXRatio2 = 0.0;
12323 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
12327 if ((this->
getModel()).isModelLinearized()){
12328 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12329 }
else if((this->
getModel()).isModelNPquadratic()){
12330 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12332 return weight*(muProd)*(BrHXXRatio);
12342:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12345 throw std::runtime_error(
"STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
12352 double weight = 1.0;
12354 double muProd1 = muProd -1.0;
12355 double muProd2 = 0.0;
12358 double BrHXXRatio = 1.0;
12359 double dBrHXXRatio1 = 0.0;
12360 double dBrHXXRatio2 = 0.0;
12364 }
else if (
fstate == 1){
12366 dBrHXXRatio1 = BrHXXRatio - 1.0;
12367 dBrHXXRatio2 = 0.0;
12368 }
else if (
fstate == 2){
12370 dBrHXXRatio1 = BrHXXRatio - 1.0;
12371 dBrHXXRatio2 = 0.0;
12372 }
else if (
fstate == 3){
12374 dBrHXXRatio1 = BrHXXRatio - 1.0;
12375 dBrHXXRatio2 = 0.0;
12376 }
else if (
fstate == 4){
12378 dBrHXXRatio1 = BrHXXRatio - 1.0;
12379 dBrHXXRatio2 = 0.0;
12380 }
else if (
fstate == 5){
12382 dBrHXXRatio1 = BrHXXRatio - 1.0;
12383 dBrHXXRatio2 = 0.0;
12385 throw std::runtime_error(
"STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
12389 if ((this->
getModel()).isModelLinearized()){
12390 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12391 }
else if((this->
getModel()).isModelNPquadratic()){
12392 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12394 return weight*(muProd)*(BrHXXRatio);
12402:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12405 throw std::runtime_error(
"STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
12412 double weight = 1.0;
12414 double muProd1 = muProd -1.0;
12415 double muProd2 = 0.0;
12418 double BrHXXRatio = 1.0;
12419 double dBrHXXRatio1 = 0.0;
12420 double dBrHXXRatio2 = 0.0;
12424 }
else if (
fstate == 1){
12426 dBrHXXRatio1 = BrHXXRatio - 1.0;
12427 dBrHXXRatio2 = 0.0;
12428 }
else if (
fstate == 2){
12430 dBrHXXRatio1 = BrHXXRatio - 1.0;
12431 dBrHXXRatio2 = 0.0;
12432 }
else if (
fstate == 3){
12434 dBrHXXRatio1 = BrHXXRatio - 1.0;
12435 dBrHXXRatio2 = 0.0;
12436 }
else if (
fstate == 4){
12438 dBrHXXRatio1 = BrHXXRatio - 1.0;
12439 dBrHXXRatio2 = 0.0;
12440 }
else if (
fstate == 5){
12442 dBrHXXRatio1 = BrHXXRatio - 1.0;
12443 dBrHXXRatio2 = 0.0;
12445 throw std::runtime_error(
"STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
12449 if ((this->
getModel()).isModelLinearized()){
12450 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12451 }
else if((this->
getModel()).isModelNPquadratic()){
12452 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12454 return weight*(muProd)*(BrHXXRatio);
12463:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12466 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
12473 double weight = 1.0;
12478 double muProd1 = muProd - 1.0;
12479 double muProd2 = 0.0;
12482 double BrHXXRatio = 1.0;
12483 double dBrHXXRatio1 = 0.0;
12484 double dBrHXXRatio2 = 0.0;
12487 weight = (0.01903+0.00538);
12488 }
else if (
fstate == 1){
12490 dBrHXXRatio1 = BrHXXRatio - 1.0;
12491 dBrHXXRatio2 = 0.0;
12492 }
else if (
fstate == 2){
12494 dBrHXXRatio1 = BrHXXRatio - 1.0;
12495 dBrHXXRatio2 = 0.0;
12496 }
else if (
fstate == 3){
12498 dBrHXXRatio1 = BrHXXRatio - 1.0;
12499 dBrHXXRatio2 = 0.0;
12500 }
else if (
fstate == 4){
12502 dBrHXXRatio1 = BrHXXRatio - 1.0;
12503 dBrHXXRatio2 = 0.0;
12504 }
else if (
fstate == 5){
12506 dBrHXXRatio1 = BrHXXRatio - 1.0;
12507 dBrHXXRatio2 = 0.0;
12509 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
12513 if ((this->
getModel()).isModelLinearized()){
12514 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12515 }
else if((this->
getModel()).isModelNPquadratic()){
12516 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12518 return weight*(muProd)*(BrHXXRatio);
12527:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12530 throw std::runtime_error(
"STXS12_ttH called with a class whose parent is not NPbase");
12537 double weight = 1.0;
12552 double muProd2 = 0.0;
12555 double BrHXXRatio = 1.0;
12556 double dBrHXXRatio1 = 0.0;
12557 double dBrHXXRatio2 = 0.0;
12559 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12560 }
else if (
fstate == 1){
12562 dBrHXXRatio1 = BrHXXRatio - 1.0;
12563 dBrHXXRatio2 = 0.0;
12564 }
else if (
fstate == 2){
12566 dBrHXXRatio1 = BrHXXRatio - 1.0;
12567 dBrHXXRatio2 = 0.0;
12568 }
else if (
fstate == 3){
12570 dBrHXXRatio1 = BrHXXRatio - 1.0;
12571 dBrHXXRatio2 = 0.0;
12572 }
else if (
fstate == 4){
12574 dBrHXXRatio1 = BrHXXRatio - 1.0;
12575 dBrHXXRatio2 = 0.0;
12576 }
else if (
fstate == 5){
12578 dBrHXXRatio1 = BrHXXRatio - 1.0;
12579 dBrHXXRatio2 = 0.0;
12580 }
else if (
fstate == 6){
12582 dBrHXXRatio1 = BrHXXRatio - 1.0;
12583 dBrHXXRatio2 = 0.0;
12584 }
else if (
fstate == 7){
12586 dBrHXXRatio1 = BrHXXRatio - 1.0;
12587 dBrHXXRatio2 = 0.0;
12589 throw std::runtime_error(
"STXS12_ttH called with invalid argument for final state in fstate_i");
12593 if ((this->
getModel()).isModelLinearized()){
12594 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12595 }
else if((this->
getModel()).isModelNPquadratic()){
12596 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12598 return weight*(muProd)*(BrHXXRatio);
12607:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12610 throw std::runtime_error(
"STXS12_tH called with a class whose parent is not NPbase");
12617 double weight = 1.0;
12619 double muProd1 = muProd -1.0;
12620 double muProd2 = 0.0;
12623 double BrHXXRatio = 1.0;
12624 double dBrHXXRatio1 = 0.0;
12625 double dBrHXXRatio2 = 0.0;
12629 }
else if (
fstate == 1){
12631 dBrHXXRatio1 = BrHXXRatio - 1.0;
12632 dBrHXXRatio2 = 0.0;
12633 }
else if (
fstate == 2){
12635 dBrHXXRatio1 = BrHXXRatio - 1.0;
12636 dBrHXXRatio2 = 0.0;
12637 }
else if (
fstate == 3){
12639 dBrHXXRatio1 = BrHXXRatio - 1.0;
12640 dBrHXXRatio2 = 0.0;
12641 }
else if (
fstate == 4){
12643 dBrHXXRatio1 = BrHXXRatio - 1.0;
12644 dBrHXXRatio2 = 0.0;
12645 }
else if (
fstate == 5){
12647 dBrHXXRatio1 = BrHXXRatio - 1.0;
12648 dBrHXXRatio2 = 0.0;
12649 }
else if (
fstate == 6){
12651 dBrHXXRatio1 = BrHXXRatio - 1.0;
12652 dBrHXXRatio2 = 0.0;
12653 }
else if (
fstate == 7){
12655 dBrHXXRatio1 = BrHXXRatio - 1.0;
12656 dBrHXXRatio2 = 0.0;
12658 throw std::runtime_error(
"STXS12_tH called with invalid argument for final state in fstate_i");
12662 if ((this->
getModel()).isModelLinearized()){
12663 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12664 }
else if((this->
getModel()).isModelNPquadratic()){
12665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12667 return weight*(muProd)*(BrHXXRatio);
12681:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12684 throw std::runtime_error(
"STXS12_ttH_tH called with a class whose parent is not NPbase");
12691 double weight = 1.0;
12701 ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12702 double muProd1 = ( muProd - 1.0 );
12703 double muProd2 = 0.0;
12706 double BrHXXRatio = 1.0;
12707 double dBrHXXRatio1 = 0.0;
12708 double dBrHXXRatio2 = 0.0;
12710 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12711 }
else if (
fstate == 1){
12713 dBrHXXRatio1 = BrHXXRatio - 1.0;
12714 dBrHXXRatio2 = 0.0;
12715 }
else if (
fstate == 2){
12717 dBrHXXRatio1 = BrHXXRatio - 1.0;
12718 dBrHXXRatio2 = 0.0;
12719 }
else if (
fstate == 3){
12721 dBrHXXRatio1 = BrHXXRatio - 1.0;
12722 dBrHXXRatio2 = 0.0;
12723 }
else if (
fstate == 4){
12725 dBrHXXRatio1 = BrHXXRatio - 1.0;
12726 dBrHXXRatio2 = 0.0;
12727 }
else if (
fstate == 5){
12729 dBrHXXRatio1 = BrHXXRatio - 1.0;
12730 dBrHXXRatio2 = 0.0;
12731 }
else if (
fstate == 6){
12733 dBrHXXRatio1 = BrHXXRatio - 1.0;
12734 dBrHXXRatio2 = 0.0;
12735 }
else if (
fstate == 7){
12737 dBrHXXRatio1 = BrHXXRatio - 1.0;
12738 dBrHXXRatio2 = 0.0;
12740 throw std::runtime_error(
"STXS12_ttH called with invalid argument for final state in fstate_i");
12744 if ((this->
getModel()).isModelLinearized()){
12745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12746 }
else if((this->
getModel()).isModelNPquadratic()){
12747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12749 return weight*(muProd)*(BrHXXRatio);
12766 throw std::runtime_error(
"muTHUggHgaga called with a class whose parent is not NPbase");
12779 throw std::runtime_error(
"muTHUVBFHgaga called with a class whose parent is not NPbase");
12791 throw std::runtime_error(
"muTHUZHgaga called with a class whose parent is not NPbase");
12803 throw std::runtime_error(
"muTHUWHgaga called with a class whose parent is not NPbase");
12815 throw std::runtime_error(
"muTHUVHgaga called with a class whose parent is not NPbase");
12827 throw std::runtime_error(
"muTHUttHgaga called with a class whose parent is not NPbase");
12839 throw std::runtime_error(
"muTHUggHZga called with a class whose parent is not NPbase");
12851 throw std::runtime_error(
"muTHUggHZgamumu called with a class whose parent is not NPbase");
12863 throw std::runtime_error(
"muTHUVBFHZga called with a class whose parent is not NPbase");
12876 throw std::runtime_error(
"muTHUZHZga called with a class whose parent is not NPbase");
12888 throw std::runtime_error(
"muTHUWHZga called with a class whose parent is not NPbase");
12900 throw std::runtime_error(
"muTHUVHZga called with a class whose parent is not NPbase");
12912 throw std::runtime_error(
"muTHUttHZga called with a class whose parent is not NPbase");
12924 throw std::runtime_error(
"muTHUggHZZ called with a class whose parent is not NPbase");
12936 throw std::runtime_error(
"muTHUVBFHZZ called with a class whose parent is not NPbase");
12948 throw std::runtime_error(
"muTHUZHZZ called with a class whose parent is not NPbase");
12960 throw std::runtime_error(
"muTHUWHZZ called with a class whose parent is not NPbase");
12972 throw std::runtime_error(
"muTHUVHZZ called with a class whose parent is not NPbase");
12984 throw std::runtime_error(
"muTHUttHZZ called with a class whose parent is not NPbase");
12996 throw std::runtime_error(
"muTHUggHZZ4l called with a class whose parent is not NPbase");
13008 throw std::runtime_error(
"muTHUggHZZ4mu called with a class whose parent is not NPbase");
13020 throw std::runtime_error(
"muTHUVBFHZZ4l called with a class whose parent is not NPbase");
13032 throw std::runtime_error(
"muTHUZHZZ4l called with a class whose parent is not NPbase");
13044 throw std::runtime_error(
"muTHUWHZZ4l called with a class whose parent is not NPbase");
13056 throw std::runtime_error(
"muTHUVHZZ4l called with a class whose parent is not NPbase");
13068 throw std::runtime_error(
"muTHUttHZZ4l called with a class whose parent is not NPbase");
13080 throw std::runtime_error(
"muTHUggHWW called with a class whose parent is not NPbase");
13092 throw std::runtime_error(
"muTHUVBFHWW called with a class whose parent is not NPbase");
13104 throw std::runtime_error(
"muTHUZHWW called with a class whose parent is not NPbase");
13116 throw std::runtime_error(
"muTHUWHWW called with a class whose parent is not NPbase");
13128 throw std::runtime_error(
"muTHUVHWW called with a class whose parent is not NPbase");
13140 throw std::runtime_error(
"muTHUttHWW called with a class whose parent is not NPbase");
13152 throw std::runtime_error(
"muTHUggHWW2l2v called with a class whose parent is not NPbase");
13164 throw std::runtime_error(
"muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
13176 throw std::runtime_error(
"muTHUZHWW2l2v called with a class whose parent is not NPbase");
13188 throw std::runtime_error(
"muTHUWHWW2l2v called with a class whose parent is not NPbase");
13200 throw std::runtime_error(
"muTHUVHWW2l2v called with a class whose parent is not NPbase");
13212 throw std::runtime_error(
"muTHUttHWW2l2v called with a class whose parent is not NPbase");
13224 throw std::runtime_error(
"muTHUggHmumu called with a class whose parent is not NPbase");
13236 throw std::runtime_error(
"muTHUVBFHmumu called with a class whose parent is not NPbase");
13248 throw std::runtime_error(
"muTHUZHmumu called with a class whose parent is not NPbase");
13260 throw std::runtime_error(
"muTHUWHmumu called with a class whose parent is not NPbase");
13272 throw std::runtime_error(
"muTHUVHmumu called with a class whose parent is not NPbase");
13284 throw std::runtime_error(
"muTHUttHmumu called with a class whose parent is not NPbase");
13296 throw std::runtime_error(
"muTHUggHtautau called with a class whose parent is not NPbase");
13308 throw std::runtime_error(
"muTHUVBFHtautau called with a class whose parent is not NPbase");
13320 throw std::runtime_error(
"muTHUZHtautau called with a class whose parent is not NPbase");
13332 throw std::runtime_error(
"muTHUWHtautau called with a class whose parent is not NPbase");
13344 throw std::runtime_error(
"muTHUVHtautau called with a class whose parent is not NPbase");
13356 throw std::runtime_error(
"muTHUttHtautau called with a class whose parent is not NPbase");
13368 throw std::runtime_error(
"muTHUggHbb called with a class whose parent is not NPbase");
13380 throw std::runtime_error(
"muTHUVBFHbb called with a class whose parent is not NPbase");
13392 throw std::runtime_error(
"muTHUZHbb called with a class whose parent is not NPbase");
13404 throw std::runtime_error(
"muTHUWHbb called with a class whose parent is not NPbase");
13416 throw std::runtime_error(
"muTHUVHbb called with a class whose parent is not NPbase");
13428 throw std::runtime_error(
"muTHUttHbb called with a class whose parent is not NPbase");
13441 throw std::runtime_error(
"muTHUVBFBRinv called with a class whose parent is not NPbase");
13455 throw std::runtime_error(
"muTHUVBFHinv called with a class whose parent is not NPbase");
13470 throw std::runtime_error(
"muTHUVHBRinv called with a class whose parent is not NPbase");
13484 throw std::runtime_error(
"muTHUVHinv called with a class whose parent is not NPbase");
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
virtual const double muggHbb(const double sqrt_s) const
virtual const double muVHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
virtual const double cbminuscc() const
virtual const double muTHUZHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHtautauRatio1() const
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUttHWW(const double sqrt_s) const
virtual const double muTHUttHZga(const double sqrt_s) const
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUttHbb(const double sqrt_s) const
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZga(const double sqrt_s) const
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double cVpluscb() const
virtual const double deltaGammaHtautauRatio2() const
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
virtual const double muttHptH_HWW(const double sqrt_s) const
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
virtual const double delta_mutH_2(const double sqrt_s) const
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double muttHgagaZeeboost(const double sqrt_s) const
The ratio in the , channel channel in the current model and in the Standard Model.
virtual const double muttHZZ4l(const double sqrt_s) const
virtual const double muVHZga(const double sqrt_s) const
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
virtual const double muTHUZHZZ(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
virtual const double muZHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
virtual const double ccminusctau() const
virtual const double muTHUttHZZ(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double muVBFHmumu(const double sqrt_s) const
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZZ4l(const double sqrt_s) const
virtual const double delta_muZH_2(const double sqrt_s) const
virtual const double cgaplusct() const
virtual const double muTHUVBFBRinv(const double sqrt_s) const
virtual const double muTHUVBFHZga(const double sqrt_s) const
virtual const double deltaGammaHbbRatio2() const
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
virtual const double muttHWW2l2v(const double sqrt_s) const
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHBRinv(const double sqrt_s) const
virtual const double delta_mutH_1(const double sqrt_s) const
virtual const double delta2sBRH3(const double C1prod, const double C1Hxx) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for in the...
virtual const double muTHUZHgaga(const double sqrt_s) const
virtual const double muTHUggHZZ(const double sqrt_s) const
virtual const double muTHUVBFHZZ(const double sqrt_s) const
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZZ(const double sqrt_s) const
virtual const double muTHUggHWW(const double sqrt_s) const
virtual const double cgplusct() const
virtual const double muttHtautau(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
virtual const double muTHUggHZga(const double sqrt_s) const
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muTHUZHbb(const double sqrt_s) const
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHWW(const double sqrt_s) const
virtual const double muWHWW(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZga(const double sqrt_s) const
virtual const double muVBFHWW2l2v(const double sqrt_s) const
virtual const double deltaGammaTotalRatio1() const
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muggHgaga(const double sqrt_s) const
virtual const double muVHcc(const double sqrt_s) const
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double muttHptH_Hgaga(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double deltaGammaHZgaRatio2() const
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHmumuRatio1() const
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
virtual const double muTHUWHbb(const double sqrt_s) const
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
virtual const double muTHUVHZZ4l(const double sqrt_s) const
virtual const double muppHmumu(const double sqrt_s) const
virtual const double muTHUVHinv(const double sqrt_s) const
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double delta_muttH_2(const double sqrt_s) const
virtual const double muZHZga(const double sqrt_s) const
virtual const double deltaGammaHmumuRatio2() const
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double muZHWW2l2v(const double sqrt_s) const
virtual const double muttHWW(const double sqrt_s) const
virtual const double muVHZZ(const double sqrt_s) const
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHZgaRatio1() const
virtual const double deltaGammaHWWRatio1() const
virtual const double muTHUVHgaga(const double sqrt_s) const
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double delta_muggH_1(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
virtual const double delta_muVBF_1(const double sqrt_s) const
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHZZRatio1() const
virtual const double muTHUVHWW(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
virtual const double muWHZga(const double sqrt_s) const
virtual const double muTHUttHtautau(const double sqrt_s) const
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
virtual const double muttHptH_HZZ(const double sqrt_s) const
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUttHgaga(const double sqrt_s) const
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muggHmumu(const double sqrt_s) const
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double muggHWW2l2v(const double sqrt_s) const
virtual const double muttHptH_Htautau(const double sqrt_s) const
virtual const double muZHbb(const double sqrt_s) const
virtual const double deltaGammaTotalRatio2() const
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
virtual const double muWHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
virtual const double muZHtautau(const double sqrt_s) const
virtual const double muTHUVBFHgaga(const double sqrt_s) const
virtual const double deltaGammaHgagaRatio2() const
virtual const double muTHUWHWW(const double sqrt_s) const
virtual const double deltaGammaHgagaRatio1() const
virtual const double mutHgaga(const double sqrt_s) const
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double delta_muttH_1(const double sqrt_s) const
virtual const double muZHgaga(const double sqrt_s) const
virtual const double UpperLimitZgammaC(const double sqrt_s) const
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
virtual const double muWHgaga(const double sqrt_s) const
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZZ4l(const double sqrt_s) const
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHbb(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
virtual const double muTHUVBFHmumu(const double sqrt_s) const
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double delta2sH3(const double C1) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for an obse...
virtual const double muTHUWHtautau(const double sqrt_s) const
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
virtual const double muZHWW(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double cbminusctau() const
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muTHUttHZZ4l(const double sqrt_s) const
virtual const double muWHZZ4l(const double sqrt_s) const
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
virtual const double muWHbb(const double sqrt_s) const
virtual const double muVHWW(const double sqrt_s) const
virtual const double muTHUVHZZ(const double sqrt_s) const
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
virtual const double muTHUWHZZ4l(const double sqrt_s) const
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
virtual const double deltaGammaHZZRatio2() const
virtual const double muWHtautau(const double sqrt_s) const
virtual const double muTHUggHtautau(const double sqrt_s) const
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
double C1HZga
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUVBFHinv(const double sqrt_s) const
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double muTHUggHgaga(const double sqrt_s) const
virtual const double muVHbb(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHZZ4l(const double sqrt_s) const
virtual const double muttHgaga(const double sqrt_s) const
virtual const double muTHUggHbb(const double sqrt_s) const
virtual const double muTHUWHgaga(const double sqrt_s) const
virtual const double muWHmumu(const double sqrt_s) const
virtual const double muZHZZ(const double sqrt_s) const
virtual const double muttHZZ(const double sqrt_s) const
virtual const double deltaGammaHbbRatio1() const
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double muWHZZ(const double sqrt_s) const
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
virtual const double muggHtautau(const double sqrt_s) const
virtual const double muttHmumu(const double sqrt_s) const
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZZ(const double sqrt_s) const
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muTHUVBFHWW(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFpVH_HZga(const double sqrt_s) const
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
double C1Hmumu
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHtautau(const double sqrt_s) const
virtual const double muTHUVHbb(const double sqrt_s) const
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
virtual const double delta_muVBF_2(const double sqrt_s) const
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
virtual const double muTHUggHZgamumu(const double sqrt_s) const
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double muVHtautau(const double sqrt_s) const
virtual const double muggHpttHptHpbbH_HZga(const double sqrt_s) const
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muttHZga(const double sqrt_s) const
virtual const double muTHUZHtautau(const double sqrt_s) const
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHgaga(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double UpperLimitZgammaA(const double sqrt_s) const
virtual const double muTHUZHZga(const double sqrt_s) const
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double delta_muZH_1(const double sqrt_s) const
virtual const double muVHmumu(const double sqrt_s) const
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muTHUVHmumu(const double sqrt_s) const
virtual const double cgminuscga() const
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
virtual const double delta_muggH_2(const double sqrt_s) const
virtual const double muTHUWHZZ(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHtautau(const double sqrt_s) const
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
virtual const double muppHZga(const double sqrt_s) const
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
virtual const double deltaGammaHWWRatio2() const
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muggHWW(const double sqrt_s) const
virtual const double cVplusctau() const
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double delta_muWH_1(const double sqrt_s) const
virtual const double muTHUVBFHtautau(const double sqrt_s) const
virtual const double muggHpbbH_HWW(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double delta_muWH_2(const double sqrt_s) const
virtual const double muttHbb(const double sqrt_s) const
virtual const double muVHZZ4l(const double sqrt_s) const
virtual const double muTHUWHZga(const double sqrt_s) const
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
virtual const double muTHUVBFHbb(const double sqrt_s) const
virtual const double muTHUWHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
virtual const double muTHUZHZZ4l(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muttHptH_Hmumu(const double sqrt_s) const
virtual const double muVHgaga(const double sqrt_s) const
virtual const double muttHptH_Hbb(const double sqrt_s) const
virtual const double muTHUttHmumu(const double sqrt_s) const
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUggHmumu(const double sqrt_s) const
virtual const double muZHZZ4l(const double sqrt_s) const
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUZHWW(const double sqrt_s) const
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHZga(const double sqrt_s) const
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH60_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
const StandardModel & getModel()
A get method to get the model.
const StandardModel & SM
A reference to an object of StandardMode class.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgagaZeeboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
master
1.9.2